Software Engineering Cheat Sheet

Updated 2026-04-27

Next Topic: Software Quality Metrics and Code Analysis Cheat Sheet

🧠Study flashcards on this topic217 cards · spaced repetition→

Software Engineering is the systematic application of engineering principles to software development, encompassing the design, development, testing, deployment, and maintenance of software systems. It bridges computer science theory with practical development methodologies, enabling teams to build scalable, maintainable, and reliable systems. Unlike ad-hoc programming, software engineering emphasizes structured processes, quality assurance, and collaborative workflows that ensure long-term project success. The discipline has evolved from waterfall models to agile practices and now integrates AI-assisted development, continuous delivery pipelines, cloud-native architectures, and platform engineering — yet core principles like modularity, testing, and clean code remain foundational to producing software that meets user needs and withstands change.

What This Cheat Sheet Covers

This topic spans 29 focused tables and 265 indexed concepts, 217 flashcards. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Software Development MethodologiesTable 2: SOLID Design PrinciplesTable 3: Object-Oriented Programming (OOP) PrinciplesTable 4: Design PatternsTable 5: Software Testing TypesTable 6: Test-Driven Development (TDD) and Behavior-Driven Development (BDD)Table 7: Version Control and Branching StrategiesTable 8: Continuous Integration/Continuous Deployment (CI/CD)Table 9: Software Architecture PatternsTable 10: Microservices Design PatternsTable 11: Domain-Driven Design (DDD)Table 12: Code Quality and RefactoringTable 13: Software Estimation TechniquesTable 14: Software Development Lifecycle (SDLC) PhasesTable 15: DevOps PracticesTable 16: Platform EngineeringTable 17: API Design PatternsTable 18: Database Design PrinciplesTable 19: Performance Optimization TechniquesTable 20: Security Best PracticesTable 21: Error Handling and LoggingTable 22: Scalability StrategiesTable 23: Containerization and OrchestrationTable 24: Deployment StrategiesTable 25: Code Collaboration PracticesTable 26: Clean Code PrinciplesTable 27: Software ObservabilityTable 28: Dependency ManagementTable 29: Software Engineering Laws

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Software Development Methodologies

How a team chooses to plan, build, and ship work shapes everything downstream. These methodologies range from the rigid, sequential Waterfall to the iterative Agile family — Scrum, Kanban, XP — and the enterprise scaling frameworks (SAFe, the Spotify Model) that coordinate many teams at once. Knowing which one fits your project's stability and size is half the battle.

Methodology	Example	Description
Agile	Sprint planning → Daily standups → Retrospectives	Iterative approach focusing on incremental delivery, continuous feedback, and adapting to changing requirements through short development cycles.
Scrum	Product backlog → 2-week sprint → Sprint review	Framework within Agile using defined roles (Scrum Master, Product Owner, Team) and time-boxed sprints to deliver working increments.
Kanban	Board with columns: To Do → In Progress → Done	Visual workflow management emphasizing continuous flow and limiting work-in-progress (WIP) to optimize throughput.
DevOps	CI/CD pipeline → Infrastructure as Code → Monitoring	Cultural and technical practice unifying development and operations to enable faster, more reliable software delivery through automation.
Extreme Programming (XP)	Pair programming + TDD + CI + small releases	Agile methodology emphasizing technical practices like pair programming, TDD, continuous integration, and frequent small releases.
SAFe (Scaled Agile Framework)	PI Planning → Agile Release Train → System Demo	• Enterprise-scale Agile framework synchronizing multiple teams • organizes work into Agile Release Trains (ARTs) delivering value every Program Increment.
Spotify Model	Squads (teams) → Tribes → Chapters → Guilds	• People-driven scaling approach organizing autonomous squads into tribes • emphasizes team culture and autonomy over rigid Agile process.
Waterfall	Requirements → Design → Implementation → Testing → Deployment	• Sequential phases where each stage completes before the next begins • best for projects with well-defined, stable requirements.
Lean	Eliminate waste → Amplify learning → Decide late	Focuses on maximizing value by eliminating non-essential activities and delivering only what customers need when they need it.
Feature-Driven Development (FDD)	Domain model → Feature list → Design/build by feature	• Model-driven approach organizing work around features • emphasizes domain object modeling and iterative feature delivery.

Table 2: SOLID Design Principles

Five object-oriented design principles, captured by the SOLID acronym, that together keep classes loosely coupled and easy to change. Each one targets a specific kind of rigidity — a class doing too much, code that breaks when extended, subtypes that don't behave like their parents — and the cure is almost always pushing dependencies toward abstractions.

Principle	Example	Description
Single Responsibility Principle (SRP)	`class UserRepository {` `save(user) { ... }` `}`	• Each class should have one reason to change • separates concerns so a class handles only a single responsibility.

The rest of this section is part of the full cheat sheet

Table 3: Object-Oriented Programming (OOP) Principles

The four classic pillars of OOP — encapsulation, inheritance, polymorphism, and abstraction — plus the modern reminder to favour composition over inheritance. These are the mental tools for modelling real-world entities as objects that bundle their own data and behaviour while hiding the messy details.

Principle	Example	Description
Encapsulation	`class BankAccount {` `private balance` `public deposit(amt) { ... }` `}`	• Bundling data and methods within a class • restricts direct access to internal state via private/public modifiers for data protection.

The rest of this section is part of the full cheat sheet

Table 4: Design Patterns

Reusable, named solutions to problems that crop up again and again in object-oriented code — the Gang of Four catalogue and a few close relatives. They fall loosely into creational (how objects are made, like Factory and Singleton), structural (how they're composed, like Adapter and Decorator), and behavioural (how they talk to each other, like Observer and Strategy). Learning them gives you a shared vocabulary for describing designs at a glance.

Pattern	Example	Description
Observer	`subject.attach(observer)` `subject.notify()`	• Defines one-to-many dependency • when one object changes state, all dependents are notified and updated automatically.

The rest of this section is part of the full cheat sheet

Table 1: Software Development Methodologies

Methodology	Example	Description
Agile	Sprint planning → Daily standups → Retrospectives	Iterative approach focusing on incremental delivery, continuous feedback, and adapting to changing requirements through short development cycles.
Scrum	Product backlog → 2-week sprint → Sprint review	Framework within Agile using defined roles (Scrum Master, Product Owner, Team) and time-boxed sprints to deliver working increments.
Kanban	Board with columns: To Do → In Progress → Done	Visual workflow management emphasizing continuous flow and limiting work-in-progress (WIP) to optimize throughput.
DevOps	CI/CD pipeline → Infrastructure as Code → Monitoring	Cultural and technical practice unifying development and operations to enable faster, more reliable software delivery through automation.
Extreme Programming (XP)	Pair programming + TDD + CI + small releases	Agile methodology emphasizing technical practices like pair programming, TDD, continuous integration, and frequent small releases.
SAFe (Scaled Agile Framework)	PI Planning → Agile Release Train → System Demo	• Enterprise-scale Agile framework synchronizing multiple teams • organizes work into Agile Release Trains (ARTs) delivering value every Program Increment.
Spotify Model	Squads (teams) → Tribes → Chapters → Guilds	• People-driven scaling approach organizing autonomous squads into tribes • emphasizes team culture and autonomy over rigid Agile process.
Waterfall	Requirements → Design → Implementation → Testing → Deployment	• Sequential phases where each stage completes before the next begins • best for projects with well-defined, stable requirements.
Lean	Eliminate waste → Amplify learning → Decide late	Focuses on maximizing value by eliminating non-essential activities and delivering only what customers need when they need it.
Feature-Driven Development (FDD)	Domain model → Feature list → Design/build by feature	• Model-driven approach organizing work around features • emphasizes domain object modeling and iterative feature delivery.

Table 2: SOLID Design Principles

Principle	Example	Description
Single Responsibility Principle (SRP)	`class UserRepository {` `save(user) { ... }` `}`	• Each class should have one reason to change • separates concerns so a class handles only a single responsibility.

Table 3: Object-Oriented Programming (OOP) Principles

Principle	Example	Description
Encapsulation	`class BankAccount {` `private balance` `public deposit(amt) { ... }` `}`	• Bundling data and methods within a class • restricts direct access to internal state via private/public modifiers for data protection.

Table 4: Design Patterns

Pattern	Example	Description
Observer	`subject.attach(observer)` `subject.notify()`	• Defines one-to-many dependency • when one object changes state, all dependents are notified and updated automatically.