Explore the Library
Engineering Education

Patterns That Power Real Systems

A living reference for engineers who design systems that must work—every time.

Explore the LibraryGet in touch

Module 1: Core Principles

Establish the foundational ideas that define robust system design—focusing on trade-offs, scalability limits, and reliability over fleeting trends.

See all →
1. Trade-Off Analysis FrameworkLesson2. Scalability vs Consistency BalanceLesson3. Defining Reliability ThresholdsLesson

Module 2: Building Blocks

Learn how to construct reliable infrastructure components—caching, queues, routing, and failure handling—using real-world patterns and constraints.

See all →
1. Caching Strategies and Eviction RulesLesson2. Queue-Based Decoupling PatternsLesson3. Request Routing Without Single PointsLesson

Module 3: Integration Patterns

Design stable interfaces between services—handling retries, idempotency, and data synchronization across distributed components.

See all →
1. Idempotency for External CallsLesson2. Synchrony Levels Across BoundariesLesson3. Data Reconciliation After FailuresLesson

Module 4: Operational Maturity

Operationalize designs through observability, capacity planning, and incident response—ensuring systems remain healthy under real-world load and change.

See all →
1. Signal Detection from MetricsLesson2. Capacity Margins and HeadroomLesson3. Post-Incident Learning CyclesLesson

Get new lessons by email

One email when something new is published on systemdesign.com. Unsubscribe any time.

Architectural Styles

Compare foundational patterns—Layered, Event-Driven, Microservices—through tradeoff tables grounded in latency, consistency, and operational complexity, not opinions.

  1. 01

    Layered (N-Tier)

    Clear separation but tight coupling; suitable when teams align to database schemas, not business capability boundaries.

  2. 02

    Event-Driven

    Decouples producers and consumers; introduces ordering, replay, and error-handling complexity at scale.

  3. 03

    Microservices

    Enables independent deployment but demands robust service discovery, observability, and data consistency strategies.

Scalability Patterns

Actionable tactics for caching, sharding, and async processing—each annotated with implementation footnotes about pitfalls (e.g., cache stampede mitigation, hot keys, event replay idempotency).

Write-Behind Caching

Reduces database load; requires durable write queues and recovery logic to prevent data loss on failure.

Range Sharding

Scales reads and writes by key ranges; avoids rebalancing overhead but risks hot shards with skewed access patterns.

SAGA Orchestration

Coordinates distributed state via choreographed messages; clearer traceability than choreography but tighter coupling in the orchestrator.

Real-World Case Studies

Annotated breakdowns of public infrastructure decisions—e.g., how Discord routes voice traffic over WebRTC with fallback paths, or how Stripe handles payment idempotency across regions—without vendor narratives.

  • Discord Voice BackendUses mesh-based routing with per-region edge nodes; fails gracefully when media servers drop packets or lose connectivity.
  • Stripe IdempotencyLeverages database constraints and TTL’d metadata tables to deduplicate requests across untrusted clients and transient failures.
  • Netflix Failover PatternsSwitches traffic via regionally replicated DNS and health-checked load balancers; avoids split-brain via centralized leadership election.

Tool & Library Matrix

Filterable tables comparing databases (e.g., CockroachDB vs. Amazon Aurora), CRDT libraries, and consensus protocols—each row includes version compatibility, consensus guarantees, and known gotchas.

01

Consensus Libraries

Compare Raft (etcd) vs. PBFT (Hyperledger) vs. Paxos variants in latency, throughput, and fault tolerance.

02

Distributed Databases

Match partition tolerance, consistency model (CA/CP/AP), and operator overhead against team expertise and SLA constraints.

03

CRDT Implementations

Assess conflict resolution semantics for G-Counters vs. PN-Counters vs. MV-Reg in offline-first and multi-region apps.

Community Contributions

Patterns submitted, reviewed, and refined by peers—each includes versioned architecture diagrams, code snippets, and peer review comments, all preserved in an immutable revision history.

Redundant Gateway Pattern

Dual upstream proxies with shared sticky session store to eliminate single-point failures at ingress.

Decoupled Migration Runner

Separates schema migration execution from deployment cycles using feature flags and schema version guards.

Batched Health Check Aggregation

Reduces dependency-check overhead by bundling probes and caching failure state with degraded TTL.

Learning Paths

Guided sequences—from fundamentals (CAP theorem, consensus basics) to advanced topics (distributed tracing, state machine replication)—with quizzes, diagram exercises, and ADR templates.

  • Distributed Systems FundamentalsBuild intuition for consistency, availability, partition tolerance, and when to relax one in practice.
  • System Design for AI InfraStructure data planes for model serving, handle variable latency in inference pipelines, and manage state in LLM-backed workflows.
  • Designing Resilient APIsCraft rate limiting, retry policies, and circuit breakers that survive client misbehavior and upstream flaps.

Get in touch

Questions or ideas about systemdesign.com? Send a note and we will get back to you.

For acquisition, partnership or investment inquiries about systemdesign.com, use this form.