Patterns Catalog
A navigable index of all 16 patterns across architecture domains. Each pattern is ranked by complexity and tagged for discovery.
By Domain
By Complexity
16 of 16 patterns
Dependency Injection
Inject external dependencies into a class rather than creating them internally, enabling loose coupling and easier testing.
Hexagonal Architecture
Organize code into a domain core surrounded by ports (interfaces) and adapters (implementations), isolating business logic from infrastructure concerns.
CQRS
Separate read and write models to optimize for different access patterns, scaling, and consistency requirements independently.
Strategy Pattern
Define a family of algorithms, encapsulate each one, and make them interchangeable, letting callers choose the strategy at runtime.
Medallion Architecture
Organize data warehouse layers (Bronze/Silver/Gold) to progressively refine raw data through validated, enriched stages.
Schema-Driven Validation
Define data schemas upfront and validate every record against them at ingest, catching quality issues early rather than downstream.
Pure Functions
Write transformation functions with no side effects — same input always produces same output, making pipelines deterministic and testable.
Batch vs Streaming
Choose between accumulated batch windows and continuous event streams based on latency tolerance, cost, and complexity trade-offs.
Component Composition
Build complex UI by assembling small, single-purpose components through nesting and prop-passing rather than monolithic inheritance.
State Management Patterns
Categorise state by scope and apply the appropriate mechanism (useState, Context, Zustand) to keep data flow predictable.
Micro-Frontend Architecture
Decompose large frontend applications into independently deployable modules owned by different teams.
Docker Port Mapping
Map container-internal ports to unique host ports to run multiple instances without reconfiguring the service itself.
Multi-Database Orchestration
Manage multiple independent database containers with isolation, health checks, and a path to production-grade hosting.
Infrastructure as Code
Declare infrastructure in version-controlled code (Terraform, Pulumi) to make deployments reproducible, reviewable, and auditable.
Single Responsibility Principle
A module, class, or function should have one reason to change, making code easier to test, maintain, and evolve safely.
Composition Over Inheritance
Prefer combining smaller objects and behaviors over building class hierarchies, reducing fragility and increasing reusability.