Design Patterns

The classic creational, structural and behavioural patterns, then concurrency, architectural and distributed ones, and when not to use one. 9 modules, about 14 hours of reading. Every lesson ends in something to do.

Foundations

Introduction to Design PatternsWhat a pattern actually is, the three families in the classic catalogue, and the more useful skill — knowing when not to reach for one.Beginner19 min
The Principles Behind the PatternsSix ideas that generate most of the catalogue — encapsulate what varies, composition over inheritance, and the rest — plus the rule of three.Beginner19 min
Reading Class and Sequence DiagramsThe small subset of UML you need to read any pattern description — the class box, five relationships, multiplicity, and messages over time.Beginner19 min

Creational Patterns

Factory MethodCentralising the decision of which concrete thing to build — and the three different things people mean when they say "factory".Intermediate17 min
Abstract FactoryWhen several objects must be chosen together or not at all — creating consistent families, and the mixing bug the pattern exists to prevent.Intermediate17 min
BuilderConstructing objects with many parts without telescoping constructors, half-built states, or a boolean nobody can read at the call site.Beginner17 min
PrototypeCreating an object by copying an existing one — and the shallow-copy bug that makes this the pattern most likely to cause a subtle data leak.Intermediate17 min
Singleton and Its AlternativesWhy the most famous pattern is the most regretted, what the legitimate need underneath it is, and how to get one instance without global reach.Beginner17 min
Object PoolReusing expensive objects instead of creating them — connection pools, the sizing question, and why a pool is a queue with a failure mode.Advanced18 min

Structural Patterns

AdapterMaking an incompatible interface fit — the boundary that keeps a vendor's vocabulary out of your domain, and the anti-corruption layer it grows into.Beginner17 min
DecoratorAdding behaviour without changing the original — composable retries, caching and metrics, and the point at which a stack becomes untraceable.Intermediate17 min
FacadeOne simple entry point over a complicated subsystem — what it legitimately hides, and how it turns into a god object if you let it.Beginner17 min
ProxyA stand-in that controls access to the real thing — lazy loading, remote calls, protection and caching, plus the N+1 problem lazy proxies cause.Intermediate18 min
CompositeTreating a single thing and a group of things identically — the pattern behind file trees and permission groups, and where the uniformity breaks.Intermediate18 min
BridgeSeparating two dimensions that would otherwise multiply into a subclass explosion — and how to tell Bridge apart from Strategy and Adapter.Advanced18 min
FlyweightSharing the identical parts of many objects to cut memory — intrinsic versus extrinsic state, string interning, and why it is a last resort.Advanced18 min

Behavioural Patterns

StrategyReplacing a growing conditional with interchangeable behaviours — the most useful pattern in the catalogue, and the one most often applied too early.Beginner17 min
ObserverDecoupling one event from many reactions — and the invisible coupling, ordering ambiguity and failure semantics you take on in exchange.Intermediate18 min
CommandTurning a request into an object so it can be queued, retried, logged, undone or authorised — and the idempotency that queueing forces on you.Intermediate18 min
StateWhen an object's behaviour depends on which state it is in — replacing status flags with a machine that makes illegal transitions impossible.Intermediate18 min
Template MethodFixing a sequence in one place and letting subclasses fill the gaps — the pattern for protecting an ordering invariant, and its inheritance cost.Intermediate18 min
Chain of ResponsibilityPassing a request along handlers until one takes it — middleware pipelines, the unhandled-request trap, and why order is part of the contract.Intermediate18 min
IteratorTraversing a collection without exposing how it stores things — lazy sequences, the invalidation trap, and why pagination is Iterator over a network.Beginner18 min
MediatorReplacing many-to-many connections with a hub that coordinates them — and how the hub becomes the god object the pattern was meant to prevent.Advanced17 min
MementoCapturing an object's state so it can be restored later, without exposing its internals — snapshots, undo, and why the copy must be deep.Intermediate17 min
VisitorAdding operations to a fixed set of types without editing them — double dispatch, the expression problem, and why it is rarely the right answer.Advanced18 min
InterpreterRepresenting a small language as a tree of objects you evaluate — where a rules DSL is worth building, and the security and performance traps.Advanced18 min

Concurrency Patterns

Producer–ConsumerDecoupling work generation from work processing with a bounded queue — where in-process backpressure comes from, and how to shut down without losing work.Advanced19 min
Immutability and Safe PublicationMaking shared state impossible to corrupt by making it impossible to change — value objects, copy-on-write, and why partly-constructed objects escape.Advanced19 min
Actors and Message PassingConfining mutable state inside single-threaded actors that communicate only by messages — the model behind event loops, and where it stops helping.Advanced18 min

Architectural Patterns

Layered and Hexagonal ArchitectureThe dependency rule that keeps business logic independent of frameworks and databases — ports and adapters, and the cost of the indirection.Advanced18 min
MVC, MVP and MVVMSeparating what the software knows from what it shows — the three presentation patterns, what actually differs between them, and the fat-controller trap.Intermediate18 min
Data Access PatternsActive Record, Data Mapper, Unit of Work and Identity Map — how objects reach storage, and which choice you are actually making.Advanced18 min
Domain Events and the Transactional OutboxPublishing facts about what happened, and the dual-write problem — why an event bus plus a database is two writes that can disagree.Advanced19 min
CQRSSeparating the model that writes from the models that read — what it genuinely buys, the eventual consistency it forces, and when it is overkill.Advanced18 min
Event SourcingStoring the sequence of changes instead of the current state — what it buys, the schema evolution problem, and why it is hard to reverse.Advanced18 min

Distributed Patterns

Circuit BreakerA stateful wrapper that stops calling a failing dependency — the three states as a State machine, and what counts as a failure.Advanced20 min
Saga and Process ManagerThe object that owns a long-running workflow — identity, persisted state, correlation, timeouts as messages, and how to test one.Advanced20 min
Messaging PatternsCompeting consumers, claim check, scatter–gather and routing — the named structures built on top of queues, and the ordering they cost you.Advanced18 min
Sidecar and AmbassadorDecorator and Proxy applied to whole processes — moving cross-cutting concerns out of the application, and what the extra hop costs.Advanced18 min
Backends for Frontends and API CompositionOne backend per client type instead of one API for everyone — where the aggregation belongs, and the duplication you accept in exchange.Advanced18 min
Materialised Views and Change Data CapturePrecomputing answers and keeping them current from the database's own log — derived data, staleness budgets, and rebuilding when a projection is wrong.Advanced18 min

Delivering Change

Strangler Fig and Branch by AbstractionReplacing a system without a big-bang rewrite — intercept and divert, or build behind a seam, and how to tell which one you need.Advanced19 min
Feature Toggles and Progressive DeliverySeparating deployment from release — the four kinds of toggle, why they must expire, and how canaries and dark launches limit blast radius.Advanced18 min

Applying Patterns

Anti-patterns and Pattern AbuseThe recurring bad solutions — god object, anaemic domain, pattern fever — why each one felt reasonable at the time, and how to reverse it.Intermediate19 min
Refactoring to PatternsArriving at a pattern from real pain instead of starting with one — the smells that point to each pattern, and the safe sequence of moves.Advanced18 min
Choosing Patterns: A Worked ExampleOne system built from scratch, deciding at each step which pattern applies and which does not — the reasoning an interview is actually testing.Advanced20 min

Foundations

Introduction to Design PatternsWhat a pattern actually is, the three families in the classic catalogue, and the more useful skill — knowing when not to reach for one.Beginner19 min

The Principles Behind the PatternsSix ideas that generate most of the catalogue — encapsulate what varies, composition over inheritance, and the rest — plus the rule of three.Beginner19 min

Reading Class and Sequence DiagramsThe small subset of UML you need to read any pattern description — the class box, five relationships, multiplicity, and messages over time.Beginner19 min

Creational Patterns

Factory MethodCentralising the decision of which concrete thing to build — and the three different things people mean when they say "factory".Intermediate17 min

Abstract FactoryWhen several objects must be chosen together or not at all — creating consistent families, and the mixing bug the pattern exists to prevent.Intermediate17 min

BuilderConstructing objects with many parts without telescoping constructors, half-built states, or a boolean nobody can read at the call site.Beginner17 min

PrototypeCreating an object by copying an existing one — and the shallow-copy bug that makes this the pattern most likely to cause a subtle data leak.Intermediate17 min

Singleton and Its AlternativesWhy the most famous pattern is the most regretted, what the legitimate need underneath it is, and how to get one instance without global reach.Beginner17 min

Object PoolReusing expensive objects instead of creating them — connection pools, the sizing question, and why a pool is a queue with a failure mode.Advanced18 min

Structural Patterns

AdapterMaking an incompatible interface fit — the boundary that keeps a vendor's vocabulary out of your domain, and the anti-corruption layer it grows into.Beginner17 min

DecoratorAdding behaviour without changing the original — composable retries, caching and metrics, and the point at which a stack becomes untraceable.Intermediate17 min

FacadeOne simple entry point over a complicated subsystem — what it legitimately hides, and how it turns into a god object if you let it.Beginner17 min

ProxyA stand-in that controls access to the real thing — lazy loading, remote calls, protection and caching, plus the N+1 problem lazy proxies cause.Intermediate18 min

CompositeTreating a single thing and a group of things identically — the pattern behind file trees and permission groups, and where the uniformity breaks.Intermediate18 min

BridgeSeparating two dimensions that would otherwise multiply into a subclass explosion — and how to tell Bridge apart from Strategy and Adapter.Advanced18 min

FlyweightSharing the identical parts of many objects to cut memory — intrinsic versus extrinsic state, string interning, and why it is a last resort.Advanced18 min

Behavioural Patterns

StrategyReplacing a growing conditional with interchangeable behaviours — the most useful pattern in the catalogue, and the one most often applied too early.Beginner17 min

ObserverDecoupling one event from many reactions — and the invisible coupling, ordering ambiguity and failure semantics you take on in exchange.Intermediate18 min

CommandTurning a request into an object so it can be queued, retried, logged, undone or authorised — and the idempotency that queueing forces on you.Intermediate18 min

StateWhen an object's behaviour depends on which state it is in — replacing status flags with a machine that makes illegal transitions impossible.Intermediate18 min

Template MethodFixing a sequence in one place and letting subclasses fill the gaps — the pattern for protecting an ordering invariant, and its inheritance cost.Intermediate18 min

Chain of ResponsibilityPassing a request along handlers until one takes it — middleware pipelines, the unhandled-request trap, and why order is part of the contract.Intermediate18 min

IteratorTraversing a collection without exposing how it stores things — lazy sequences, the invalidation trap, and why pagination is Iterator over a network.Beginner18 min

MediatorReplacing many-to-many connections with a hub that coordinates them — and how the hub becomes the god object the pattern was meant to prevent.Advanced17 min

MementoCapturing an object's state so it can be restored later, without exposing its internals — snapshots, undo, and why the copy must be deep.Intermediate17 min

VisitorAdding operations to a fixed set of types without editing them — double dispatch, the expression problem, and why it is rarely the right answer.Advanced18 min

InterpreterRepresenting a small language as a tree of objects you evaluate — where a rules DSL is worth building, and the security and performance traps.Advanced18 min

Concurrency Patterns

Producer–ConsumerDecoupling work generation from work processing with a bounded queue — where in-process backpressure comes from, and how to shut down without losing work.Advanced19 min

Immutability and Safe PublicationMaking shared state impossible to corrupt by making it impossible to change — value objects, copy-on-write, and why partly-constructed objects escape.Advanced19 min

Actors and Message PassingConfining mutable state inside single-threaded actors that communicate only by messages — the model behind event loops, and where it stops helping.Advanced18 min

Architectural Patterns

Layered and Hexagonal ArchitectureThe dependency rule that keeps business logic independent of frameworks and databases — ports and adapters, and the cost of the indirection.Advanced18 min

MVC, MVP and MVVMSeparating what the software knows from what it shows — the three presentation patterns, what actually differs between them, and the fat-controller trap.Intermediate18 min

Data Access PatternsActive Record, Data Mapper, Unit of Work and Identity Map — how objects reach storage, and which choice you are actually making.Advanced18 min

Domain Events and the Transactional OutboxPublishing facts about what happened, and the dual-write problem — why an event bus plus a database is two writes that can disagree.Advanced19 min

CQRSSeparating the model that writes from the models that read — what it genuinely buys, the eventual consistency it forces, and when it is overkill.Advanced18 min

Event SourcingStoring the sequence of changes instead of the current state — what it buys, the schema evolution problem, and why it is hard to reverse.Advanced18 min

Distributed Patterns

Circuit BreakerA stateful wrapper that stops calling a failing dependency — the three states as a State machine, and what counts as a failure.Advanced20 min

Saga and Process ManagerThe object that owns a long-running workflow — identity, persisted state, correlation, timeouts as messages, and how to test one.Advanced20 min

Messaging PatternsCompeting consumers, claim check, scatter–gather and routing — the named structures built on top of queues, and the ordering they cost you.Advanced18 min

Sidecar and AmbassadorDecorator and Proxy applied to whole processes — moving cross-cutting concerns out of the application, and what the extra hop costs.Advanced18 min

Backends for Frontends and API CompositionOne backend per client type instead of one API for everyone — where the aggregation belongs, and the duplication you accept in exchange.Advanced18 min

Materialised Views and Change Data CapturePrecomputing answers and keeping them current from the database's own log — derived data, staleness budgets, and rebuilding when a projection is wrong.Advanced18 min

Delivering Change

Strangler Fig and Branch by AbstractionReplacing a system without a big-bang rewrite — intercept and divert, or build behind a seam, and how to tell which one you need.Advanced19 min

Feature Toggles and Progressive DeliverySeparating deployment from release — the four kinds of toggle, why they must expire, and how canaries and dark launches limit blast radius.Advanced18 min

Applying Patterns

Anti-patterns and Pattern AbuseThe recurring bad solutions — god object, anaemic domain, pattern fever — why each one felt reasonable at the time, and how to reverse it.Intermediate19 min

Refactoring to PatternsArriving at a pattern from real pain instead of starting with one — the smells that point to each pattern, and the safe sequence of moves.Advanced18 min

Choosing Patterns: A Worked ExampleOne system built from scratch, deciding at each step which pattern applies and which does not — the reasoning an interview is actually testing.Advanced20 min

Foundations

Creational Patterns

Structural Patterns

Behavioural Patterns

Concurrency Patterns

Architectural Patterns

Distributed Patterns

Delivering Change

Applying Patterns

Foundations

Creational Patterns

Structural Patterns

Behavioural Patterns

Concurrency Patterns

Architectural Patterns

Distributed Patterns

Delivering Change

Applying Patterns

Your progress