Introduction to GoF Design Patterns – What They Are, When to Use with GitHub Examples

June 18, 2025

Design patterns are time-tested, battle-hardened solutions to recurring design problems in software engineering. They help you write cleaner, more maintainable, and more scalable code by providing a shared language and best practices for solving architectural and structural challenges.

Whether you’re building APIs, handling business logic, or integrating with third-party services, knowing when and how to apply these patterns can drastically improve your architecture.

📌 What are Design Patterns?

Design patterns are general reusable solutions to commonly occurring problems in software design. They are not code snippets, but blueprints or templates that guide implementation. The Gang of Four (GoF) Design Patterns refer to a set of 23 classic software design patterns, documented in the highly influential 1994 book Design Patterns: Elements of Reusable Object-Oriented Software.

🧠 Why Use Design Patterns?

🎯 This Guide

This guide is a curated list of all 23 GoF design patterns, ordered by real-world backend usefulness and relevance (subjective) in modern industry applications.

Each pattern includes:

🧩 Design Patterns for Backend Developers

1. Strategy (Behavioral)

✅ Defines a family of interchangeable algorithms or behaviors and encapsulates each one.
🕐 Use when you have multiple ways to perform a task and want to switch logic at runtime without if-else or switch.
🔗 Example → GitHub

2. Observer (Behavioral)

✅ Enables a one-to-many dependency so when one object changes state, all dependents are notified.
🕐 Use for implementing event-driven communication (e.g., domain or integration events).
🔗 Example → GitHub

3. Factory Method (Creational)

✅ Provides an interface for creating objects, allowing subclasses or context to decide which to instantiate.
🕐 Use when object creation depends on conditions and you want to avoid direct instantiation.
🔗 Example → GitHub

4. Decorator (Structural)

✅ Adds behavior to individual objects without changing their structure or affecting others.
🕐 Use to apply logging, caching, or authorization logic dynamically around core functionality.
🔗 Example → GitHub

5. Adapter (Structural)

✅ Converts the interface of one class into another expected by the client.
🕐 Use when integrating with third-party APIs or systems that don’t match your internal models.
🔗 Example → GitHub

6. Command (Behavioral)

✅ Encapsulates a request as an object, allowing for parameterization and queuing.
🕐 Use for encapsulating operations like audit logging, action queuing, or as part of a CQRS architecture.
🔗 Example → GitHub

7. Singleton (Creational)

✅ Ensures a class has only one instance and provides a global access point to it.
🕐 Use for shared configuration, logging, or caching components.
🔗 Example → GitHub

8. Builder (Creational)

✅ Builds complex objects step-by-step without using a telescoping constructor (having multiple constructors with increasing parameters).
🕐 Use when creating objects that require many optional or configurable parameters.
🔗 Example → GitHub

9. Proxy (Structural)

✅ Acts as a placeholder or surrogate for another object, controlling access.
🕐 Use for lazy loading, access control, rate limiting, etc.
🔗 Example → GitHub

10. Chain of Responsibility (Behavioral)

✅ Passes a request along a chain of handlers until one handles it.
🕐 Use to create processing pipelines (e.g., authorization, validation, logging, middleware).
🔗 Example → GitHub

11. Composite (Structural)

✅ Treats individual objects and groups uniformly.
🕐 Use when representing tree structures like permissions or organizational units.
🔗 Example → GitHub

12. Template Method (Behavioral)

✅ Defines the skeleton of an algorithm, deferring steps to subclasses.
🕐 Use when multiple classes share the same workflow but differ in steps.
🔗 Example → GitHub

13. Facade (Structural)

✅ Provides a simplified interface to a complex system.
🕐 Use when exposing simplified operations for external clients or APIs.
🔗 Example → GitHub

14. State (Behavioral)

✅ Allows an object to alter its behavior when its internal state changes.
🕐 Use for workflows like order/payment or any other status transitions.
🔗 Example → GitHub

15. Abstract Factory (Creational)

✅ Creates families of related or dependent objects without specifying concrete classes.
🕐 Use when you need to provide a family of related components without tightly coupling the client to specific classes.
🔗 Example → GitHub

16. Mediator (Behavioral)

✅ Centralizes communication between components to reduce coupling by introducing a central coordinator.
🕐 Use when multiple components interact in complex ways.
🔗 Example → GitHub

17. Bridge (Structural)

✅ Decouples abstraction (what is done) from implementation (how it is done).
🕐 Use when you want to avoid tight coupling between logic and its implementation, like logging to different outputs or switching data sources.
🔗 Example → GitHub

18. Flyweight (Structural)

✅ Shares data between many fine-grained objects to save memory.
🕐 Use for immutable data reused at scale (e.g., country codes, currency).
🔗 Example → GitHub

19. Prototype (Creational)

✅ Creates new objects by cloning existing ones.
🕐 Use for performance optimization, object pools, or similar object copies.
🔗 Example → GitHub

20. Iterator (Behavioral)

✅ Provides a way to access elements of a collection sequentially.
🕐 Use to abstract traversal logic from the client (e.g., paged DB results).
🔗 Example → GitHub

21. Memento (Behavioral)

✅ Captures and restores an object’s internal state without violating encapsulation.
🕐 Use for undo/redo functionality, or state snapshots.
🔗 Example → GitHub

22. Interpreter (Behavioral)

✅ Defines a way to evaluate grammar or expressions.
🕐 Use for parsing simple DSLs (Domain-Specific Language), rules, or formula logic.
🔗 Example → GitHub

23. Visitor (Behavioral)

✅ Lets you add new operations to existing object structures without modifying them.
🕐 Use when you need to perform different operations across a collection of object types without changing their classes. Often an overkill unless you’re operating on complex object structures (like compilers or ASTs).
🔗 Example → GitHub

🙌 Follow & Stay Tuned

I’ll be publishing in-depth articles on selected high-impact patterns with real-world use cases hopefully soon.
🔗 Follow me on LinkedIn for updates.
You can ⭐ the GitHub repo if you found this useful!