Home / Learn / Software Engineering

🏗️ Software Engineering

Building software that lasts. 50 topics, from beginner to advanced.

Software engineering is the discipline of building software that stays correct, understandable and changeable over years. The topics here cover requirements, design, architecture, testing, code review and maintenance. They focus on the habits that let teams ship features without breaking what already works.

Who this area is for

Developers moving from solo projects to teams, students who want to understand how real software is planned and maintained, and team leads who want shared practices.

Real-world use cases

Splitting a large application into modules that teams can change independently.
Writing automated tests that catch regressions before release.
Running code reviews to share knowledge and catch defects early.
Estimating how long a new feature will take before the team commits to a release date.
Using a code review checklist so that every change is checked for security and tests.

Topics in Software Engineering

Beginner (17)

Software Development Life Cycle — Phases from planning through deployment and maintenance.
Requirements Gathering — Eliciting what stakeholders need a system to do.
Waterfall Model — Sequential phase-by-phase development process.
Agile Methodology — Iterative development embracing change and feedback.
Scrum — Agile framework with sprints, roles and ceremonies.
Kanban — Visual flow-based method limiting work in progress.
User Stories — Short descriptions of features from a user's perspective.
UML Diagrams — Standard notation for modeling software structure and behavior.
Version Control Concepts — Tracking changes to code over time.
Code Style and Readability — Conventions that keep code understandable.
Code Reviews — Peer examination of changes before merging.
Unit Testing — Verifying small isolated pieces of code.
Integration Testing — Checking that components work together.
Test-Driven Development — Writing failing tests before the code that satisfies them.
Software Documentation — Written guides and references for users and developers.
Bug Tracking — Recording and managing defects through resolution.
Software Maintenance — Fixing, adapting and improving software after release.

Intermediate (17)

SOLID Principles — Five guidelines for maintainable object-oriented design.
DRY, KISS and YAGNI — Heuristics against duplication, complexity and speculation.
Design Patterns — Reusable solutions to recurring design problems.
Singleton Pattern — Ensuring a class has only one instance.
Factory Pattern — Delegating object creation to a dedicated method.
Observer Pattern — Notifying dependents automatically when state changes.
Strategy Pattern — Swapping interchangeable algorithms at runtime.
Decorator Pattern — Adding behavior by wrapping objects.
Dependency Injection — Supplying a component's dependencies from outside.
MVC Architecture — Separating model, view and controller responsibilities.
Refactoring — Restructuring code without changing behavior.
Technical Debt — Future cost incurred by expedient design shortcuts.
Code Smells — Surface hints of deeper design problems.
Layered Architecture — Organizing code into stacked responsibility tiers.
Clean Architecture — Dependency rules keeping business logic independent of frameworks.
Domain-Driven Design — Modeling software around the business domain's language.
Microservices — Systems composed of small independently deployable services.

Advanced (16)

Monolith vs Microservices — Trade-offs between single-deployable and service-based systems.
Event-Driven Architecture — Components communicating through produced and consumed events.
CQRS and Event Sourcing — Separating reads from writes and storing changes as events.
API Design — Crafting clear stable interfaces between systems.
REST — Architectural style using resources and standard HTTP verbs.
GraphQL — Query language letting clients request exactly the data they need.
Software Metrics — Measurements of size, complexity and quality.
Cyclomatic Complexity — Count of independent paths through code.
Performance Profiling — Measuring where programs spend time and memory.
Formal Verification — Mathematically proving software meets its specification.
Mutation Testing — Evaluating test strength by injecting faults.
Property-Based Testing — Checking invariants against many generated inputs.
Chaos Engineering — Deliberately injecting failure to test resilience.
Site Reliability Engineering — Applying software practice to operations with error budgets.
Software Estimation — Predicting effort and schedule for development work.
Open Source Practices — Collaboration models around publicly shared code.

How to study Software Engineering

Pick a small project and apply one practice at a time: write a requirement, design it on paper, add tests, then review a teammate’s change. Reflect on which practice removed the most pain, and keep that habit for the next project.

Frequently asked questions

What is the difference between software engineering and programming?

Programming is writing code that works. Software engineering also covers planning, design, testing, teamwork and long-term maintenance of that code.

Why does software design matter?

Good design keeps components loosely coupled, so a change in one place does not break unrelated code. It lowers the cost of every future change.

How much testing is enough?

Test the behavior that matters most: core logic, edge cases and past bugs. Coverage numbers help, but meaningful assertions matter more than a high percentage.

Is software engineering only useful for large teams?

No. Practices such as clear naming, small changes, tests and version control pay off for one person too, especially when you return to a project after months away.

Which design pattern should I learn first?

Start with the ones you already use without knowing their names, such as the strategy and observer patterns. Learning the names then makes it easier to discuss designs with colleagues.

Open the interactive Software Engineering area Take the Software Engineering quiz