Design Patterns

Introduction

My journey in software engineering has been one of constant adaptation. I began my career mastering the foundational Gang of Four patterns, learning to craft elegant, decoupled, and maintainable object-oriented systems. These patterns Abstract Factory, Singleton, Adapter, Decorator were the bedrock of building robust applications. For years, they were the primary tools in my architectural toolkit.

But the industry’s landscape shifted beneath our feet.

We moved from monoliths to microservices, from local servers to distributed cloud environments. This new world brought new challenges: unreliable networks, eventual consistency, and the need for horizontal scale. I quickly learned that the classic patterns, while still essential, were no longer enough.

To build resilient, scalable systems, I had to master a new set of blueprints patterns like Circuit Breaker to handle failures, Saga to manage distributed transactions, Gateway Aggregation to simplify client communication, and Event Sourcing to capture immutable state.

This guide is the resource I wish I’d had during that transition. It is born from years of practical experience, connecting the dots between classic object-oriented design and the demands of modern, distributed architecture. It’s my effort to distill decades of learning from debugging a faulty Singleton in a multithreaded environment to orchestrating a production-wide Strangler Fig migration into a single, comprehensive resource.

My focus here is not just on the what (the pattern’s definition) but on the why and how.

• When do you reach for Retry versus Circuit Breaker?
• What are the real-world trade-offs of CQRS?
• How does a Sidecar enhance security without cluttering your core application logic?
• Why might Sharding outperform vertical scaling in a high-throughput system?

To make this vast topic digestible, I have organized these patterns into 13 distinct categories, from foundational GoF patterns to advanced strategies for fault isolation, load distribution, data optimization, and system evolution. Each entry is a concise, practical capsule complete with intent, structure, real-world applicability, and trade-offs designed for aspiring architects and senior developers who need to build, maintain, and scale complex software ecosystems.

Whether you are preparing for a high-stakes design interview or are the architect on the ground facing your next big challenge, this collection is your companion for building better software.

1. Object Creation Patterns (Gang of Four Creational)

These patterns focus on mechanisms for instantiating objects in a flexible and decoupled manner.

2. Object Composition Patterns (Gang of Four Structural)

These patterns address how classes and objects are composed to form larger structures while maintaining simplicity and flexibility.

Pattern	Summary
Adapter	Matches interfaces of different classes, converting the interface of a class into another interface that clients expect.
Bridge	Separates an object’s interface from its implementation, allowing the two to vary independently.
Composite	A tree structure of simple and composite objects, composing objects into tree structures to represent part-whole hierarchies.
Decorator	Adds responsibilities to objects dynamically, attaching additional responsibilities to an object without affecting other objects.
Facade	A single class that represents an entire subsystem, providing a unified interface to a set of interfaces in a subsystem.
Flyweight	A fine-grained instance used for efficient sharing, employing sharing to support large numbers of fine-grained objects efficiently.
Proxy	An object representing another object, providing a surrogate or placeholder for another object to control access to it.

3. Object Interaction Patterns (Gang of Four Behavioral)

These patterns manage algorithms, relationships, and responsibilities among objects to enhance communication and flexibility.

Pattern	Summary
Chain of Responsibility	A way of passing a request between a chain of objects, avoiding coupling the sender of a request to its receiver by giving more than one object a chance to handle the request.
Command	Encapsulates a command request as an object, parameterizing clients with queues, requests, or operations.
Interpreter	A way to include language elements in a program, defining a representation for a grammar along with an interpreter that uses the representation to interpret sentences in the language.
Iterator	Sequentially accesses the elements of a collection, providing a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
Mediator	Defines simplified communication between classes, reducing dependencies between objects by introducing a mediator object that handles interactions.
Memento	Captures and restores an object’s internal state, allowing an object to restore its previous state without violating encapsulation.
Observer	A way of notifying change to a number of classes, defining a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
State	Alters an object’s behavior when its state changes, allowing an object to alter its behavior when its internal state changes as if its class had changed.
Strategy	Encapsulates an algorithm inside a class, defining a family of algorithms, encapsulating each one, and making them interchangeable.
Template Method	Defers the exact steps of an algorithm to a subclass, defining the skeleton of an algorithm in an operation while deferring some steps to subclasses.
Visitor	Defines a new operation to a class without change, representing an operation to be performed on the elements of an object structure without changing the classes of the elements.

4. Network Mediation Patterns

These patterns handle communication, routing, and offloading in networked systems to enhance reliability and security.

Pattern	Summary
Ambassador	Encapsulates and manages network communications by offloading cross-cutting tasks that are related to network communication, providing an opportunity to augment security or add reliability patterns such as retry or buffering.
Gateway Aggregation	Simplifies client interactions with your workload by aggregating calls to multiple backend services in a single request, reducing public surface area and enabling independent evolution of backend logic.
Gateway Offloading	Offloads request processing to a gateway device before and after forwarding the request to a backend node, centralizing functionality like security features or reducing per-node complexity.
Gateway Routing	Routes incoming network requests to various backend systems based on request intents, business logic, and backend availability, enabling load balancing and decoupling requests from backends.
Gatekeeper	Offloads request processing specifically for security and access control enforcement before and after forwarding the request to a backend node, centralizing functionalities like firewalls or throttling.

5. Fault Isolation and Recovery Patterns

These patterns isolate failures and provide mechanisms for recovery to maintain system resilience.

Pattern	Summary
Bulkhead	Introduces intentional and complete segmentation between components to isolate the blast radius of malfunctions, containing faults or security incidents to the affected bulkhead.
Circuit Breaker	Prevents continuous requests to a malfunctioning or unavailable dependency, enabling graceful degradation and self-healing by avoiding overload during recovery.
Retry	Addresses transient failures by retrying operations in a controlled manner, improving resilience in distributed systems.
Compensating Transaction	Provides a mechanism to recover from failures by reversing the effects of previously applied actions, addressing malfunctions in critical paths.
Saga Distributed Transactions	Coordinates long-running transactions by decomposing work into sequences of smaller, independent transactions with compensating actions to maintain integrity.
Leader Election	Establishes a leader among distributed instances to coordinate responsibilities, implementing failover via consensus algorithms.
Scheduler Agent Supervisor	Efficiently distributes and redistributes tasks across a system based on observable factors, using health metrics to reroute tasks to healthy agents and mitigate malfunctions.

6. Data Handling and Optimization Patterns

These patterns manage data access, storage, and processing for efficiency and reliability.

Pattern	Summary
Cache-Aside	Optimizes access to frequently read data by introducing a cache that’s populated on demand, preserving availability if the origin data store is temporarily unavailable.
Claim Check	Separates data from the messaging flow, providing a way to separately retrieve the data related to a message, increasing reliability for underlying data and potentially reducing messaging costs.
Event Sourcing	Treats state change as a series of events, capturing them in an immutable, append-only log, facilitating state reconstruction and reliable history in complex processes.
Index Table	Optimizes data retrieval in distributed data stores by enabling clients to look up metadata, avoiding full scans and facilitating failover.
Materialized View	Uses precomputed views of data to optimize retrieval, storing results of complex computations to reduce resource consumption.
Command and Query Responsibility Segregation (CQRS)	Separates read and write operations of an application’s data model, enabling targeted performance and scaling optimizations.
Pipes and Filters	Breaks down complex data processing into independent stages, enabling focused attention on each stage for reliability and maintainability.
Sequential Convoy	Maintains concurrent messaging ingress while supporting processing in a defined order, eliminating race conditions.

7. Load Distribution and Scaling Patterns

These patterns manage workload distribution, scaling, and leveling to handle varying demands.

Pattern	Summary
Backends for Frontends	Individualizes the service layer by creating separate services exclusive to specific frontend interfaces, optimizing for client constraints and prioritizing reliability or security.
Competing Consumers	Applies distributed and concurrent processing to efficiently handle items in a queue, enabling scaling based on queue depth and building redundancy.
Queue-Based Load Leveling	Controls incoming requests by buffering them in a queue, providing resilience against spikes and decoupling intake from processing.
Priority Queue	Ensures higher-priority items are processed before lower-priority ones, focusing efforts on critical or time-sensitive work.
Sharding	Directs load to specific logical destinations, enabling colocation for optimization and isolating malfunctions or resource competition.
Throttling	Imposes limits on request rates to prevent resource exhaustion, mitigating congestion and supporting graceful degradation.
Rate Limiting	Controls client request rates to reduce throttling errors and avoid unbounded retries, protecting against overload.
Geode	Deploys systems in active-active modes across geographies with data replication, withstanding outages and reducing latency.
Deployment Stamps	Releases a specific version of an application and infrastructure as a controlled unit, aligning with immutable infrastructure and scaling out via additional stamps.

8. Access Control and Security Patterns

These patterns emphasize secure access, identity management, and threat mitigation.

Pattern	Summary
Federated Identity	Delegates trust to an external identity provider for managing users and authentication, using modern protocols for threat detection and shifting reliability.
Valet Key	Grants security-restricted access to a resource without using an intermediary, limiting scope and duration for auditable, revocable access.
Quarantine	Ensures external assets meet quality levels before authorization, serving as initial security validation in a segmented environment.
Sidecar	Extends application functionality by encapsulating nonprimary tasks in a companion process, reducing surface area and adding cross-cutting security controls.

9. Resource Utilization Patterns

These patterns optimize compute, storage, and other resources for cost and efficiency.

Pattern	Summary
Compute Resource Consolidation	Optimizes resources by increasing density, combining components on shared infrastructure to maximize utilization and reduce overprovisioning.
Static Content Hosting	Optimizes delivery of static content using a specialized platform, offloading from dynamic hosts to mitigate costs and congestion.

10. System Evolution and Integration Patterns

These patterns support migration, modernization, and integration with legacy systems.

Pattern	Summary
Strangler Fig	Systematically replaces components of a running system with new ones during migration, mitigating risks through incremental changes.
Anti-Corruption Layer	Protects new components from legacy behaviors by adding a mediator layer, useful in gradual migrations to reduce technical debt.
Asynchronous Request-Reply	Improves responsiveness by decoupling request and reply phases, maximizing concurrency for non-immediate processes.

11. Messaging and Decoupling Patterns

These patterns decouple components to enhance flexibility and independence.

Pattern	Summary
Publisher/Subscriber	Decouples components by replacing direct communication with an intermediate message broker, enabling event-driven approaches and network isolation.
Messaging Bridge	Provides an intermediary for communication between incompatible messaging systems, increasing longevity and interoperability.
Choreography	Coordinates autonomous distributed components using decentralized, event-driven communication, supporting frequent updates.

12. Observability and Configuration Patterns

These patterns enable monitoring, health checks, and dynamic configuration.

Pattern	Summary
Health Endpoint Monitoring	Provides a way to monitor system health via a dedicated endpoint, aiding in alerting, load balancing, and self-healing.
External Configuration Store	Extracts configuration to an external service for dynamic updates without redeployments, supporting environment-specific values and feature flags.

13. Application Structure Patterns

These patterns define high-level architectural styles for organizing applications.

Pattern	Summary
Microservices Architecture	Structures an application as a collection of loosely coupled, independently deployable services focused on specific business capabilities, promoting scalability and agility.
MVC (Model-View-Controller)	Separates an application into Model (data and logic), View (interface), and Controller (input handling), facilitating organized code in web and desktop applications.
MVVM (Model-View-ViewModel)	Enhances MVC with a ViewModel intermediary for data binding and UI logic, improving testability in rich user interface applications.