1.
Core Phases of the SDLC (Software Development Life Cycle)
Requirements Engineering
This is where you figure out what the software needs to do. It involves talking to
stakeholders (clients, users, business owners) to understand their needs, then documenting
them clearly.
Functional requirements: what the system should do (e.g., "users can reset their
password")
Non-functional requirements: how the system should behave (e.g., "the page should
load in under 2 seconds")
Design
Once you know what to build, you plan how to build it.
Architecture design: the big-picture structure (e.g., microservices vs monolith)
Database design: how data is structured and related (tables, schemas)
UI/UX design: how the interface looks and feels for users
Implementation/Coding
This is the actual writing of code based on the design. Developers use programming
languages, frameworks, and libraries to build the features.
Testing
Making sure the software actually works correctly.
Unit testing: testing individual pieces of code (like one function)
Integration testing: testing how different pieces work together
System testing: testing the whole system as one unit
Acceptance testing: confirming it meets what the client/user actually wanted
Deployment
Releasing the software so real users can use it — this could mean publishing an app to app
stores, pushing code to a live server, etc.
Maintenance
After release, software needs ongoing care — fixing bugs, patching security holes, adding
new features, and adapting to changes (like new OS versions).
2. Major Sub-Disciplines (from SWEBOK)
These are the "official" knowledge areas that define software engineering as a profession:
Software Requirements – same as above, the formal study of gathering/analyzing
needs
Software Design – formal principles behind structuring software well (patterns,
modularity, coupling/cohesion)
Software Construction – best practices for actually writing good code (naming,
readability, algorithms)
Testing & QA – systematic approaches to catching bugs and ensuring quality
Maintenance & Evolution – how software changes and grows over years, avoiding
"technical debt"
Configuration Management – tracking changes to code over time (Git is the most
common tool), managing different versions/releases
Engineering Management – planning timelines, budgets, assigning people to tasks,
tracking progress
Engineering Process – how teams work (Agile, Waterfall, etc. — covered more
below)
Tools & Methods – the software used to build software (IDEs like VS Code, testing
frameworks, CI/CD tools)
Software Quality – attributes like reliability (doesn't crash), performance (fast),
security, usability (easy to use)
Engineering Economics – estimating cost/time, deciding if a project is worth building
Computing Foundations – core CS knowledge: algorithms, data structures, operating
systems, networking
Mathematical Foundations – logic, discrete math, statistics that underpin algorithms
and reasoning about code
3. Architectural/Technical Components
This is about the actual pieces that make up a working application:
Frontend/UI – the part users see and click on (buttons, forms, pages) — built with
things like HTML/CSS/JavaScript, React, etc.
Backend/Server-side logic – the "brain" that processes requests, applies business
rules, talks to the database
Database – where data is stored permanently (like user accounts, orders, messages)
— SQL (MySQL, PostgreSQL) or NoSQL (MongoDB)
APIs – "messengers" that let different parts of software talk to each other (e.g., your
app's frontend asking the backend for data)
Infrastructure/DevOps – the servers, cloud platforms (AWS, Azure), and pipelines
that host and deploy your app
Security – protecting the system: verifying who users are (authentication), controlling
what they can access (authorization), and protecting data
4. Process & Methodology Layer
This is about how teams organize their work:
Agile – building software in small, iterative chunks (called "sprints"), getting feedback
often, and adjusting quickly
Scrum – a specific Agile framework with defined roles (Scrum Master, Product
Owner), ceremonies (daily standups, sprint planning)
Kanban – visualizing work as cards moving through columns (To Do → In Progress →
Done), focused on continuous flow
Waterfall – a traditional, sequential approach: finish requirements fully, then design
fully, then build fully, then test — one phase at a time, no going back
DevOps – a culture/practice that merges development and operations teams so
software can be built, tested, and released faster and more reliably
Version Control – tracking every change made to code (using Git), allowing multiple
people to work without overwriting each other, and letting you roll back mistakes
CI/CD (Continuous Integration/Continuous Deployment) – automatically testing and
deploying code every time it changes, so releases happen frequently and safely
5. People & Roles
Software Engineers/Developers – write and maintain the code
Software Architects – design the overall technical structure and make high-level
technical decisions
QA/Test Engineers – specialize in finding bugs and ensuring quality before release
DevOps Engineers – manage infrastructure, deployment pipelines, and system
reliability
Product/Project Managers – decide what gets built and when, coordinate the team,
manage timelines
UI/UX Designers – design how the software looks and how users experienc