📐 Systems Design & Scalability: Sub-Curriculum Index

Welcome to the Systems Design & Scalability curriculum. This track covers large-scale distributed systems design, capacity estimation, high-availability architecture, caching layers, rate limiting, consistent hashing, database partitioning, and fault-tolerant reliability patterns.

Every guide in this series strictly follows a two-part learning format:

  • ⚡ Quick Dive: Architecture cheat sheets, calculation quick-formulas, and trade-off comparison tables.
  • 📖 Extended Guide: Deep technical breakdowns, mathematical models, component topologies, and real-world system designs.

📚 Complete Curriculum Roadmap

Part 1: System Design Methodology & Foundations

# Guide Primary Topics Covered
01 System Design Playbook Structured framework for tackling system design interviews and production design proposals.
02 Requirements Clarification Functional vs. non-functional requirements, traffic profiles, and SLA/SLO definition.
03 Capacity Estimation & Back-of-Envelope QPS calculations, storage projections, network bandwidth math, and memory sizing rules of thumb.
04 High-Level Design (HLD) Architecture diagrams, component interaction flows, and API boundary definitions.
05 Low-Level Design (LLD) Class diagrams, data models, concurrency control, and schema specifications.
06 Design Review Checklist Production readiness review, security auditing, disaster recovery, and operational checklist.
07 System Design Trade-Offs Latency vs. Throughput, Consistency vs. Availability, and Read vs. Write heavy architectures.
08 Trade-Off Analysis Framework Decision matrices and quantitative evaluation models for choosing architecture components.
09 Scalability and Performance Horizontal vs. vertical scaling, stateless services, and eliminating single points of bottleneck.
10 Reducing Latency Connection pooling, serialization optimization, proximity caching, and async non-blocking I/O.

Part 2: Distributed Systems Core Primitives

# Guide Primary Topics Covered
11 CAP Theorem & Distributed Systems Consistency, Availability, Partition Tolerance, PACELC theorem, and consensus models (Raft/Paxos).
12 Consistent Hashing Hash rings, virtual nodes, rehashing mitigation ($O(K/N)$ key movement), and distributed cache balancing.
13 Load Balancing Fundamentals L4 vs. L7 load balancing, DNS balancing, hardware vs. software, and health checks.
14 Load Balancing Use Cases Real-world patterns: Global Server Load Balancing, reverse proxy tiers, and microservice mesh routing.
15 Traffic Routing Components Anycast, Edge Routers, Ingress Controllers, Service Discovery, and Circuit Breaker routing.
16 API Gateway Request routing, authentication, rate limiting, telemetry aggregation, and SSL termination.
17 Backends for Frontends (BFF) Dedicated BFF layers for Mobile vs. Web vs. Third-Party clients, data aggregation, and payload pruning.
18 Caching Strategies & Topologies Cache-Aside, Write-Through, Write-Back, Refresh-Ahead, Eviction policies (LRU, LFU), and Cache Stampede prevention.
19 Rate Limiting Algorithms Token Bucket, Leaky Bucket, Fixed Window, Sliding Window Log, and Sliding Window Counter.

Part 3: Microservices, Storage & Data Systems

# Guide Primary Topics Covered
20 Microservices Architecture Bounded contexts, service boundaries, independent deployability, and database-per-service patterns.
21 Essential Components of Microservices Service discovery (Consul/Eureka), distributed tracing, centralized logging, and config management.
22 Data Sharing Between Microservices Synchronous REST/gRPC vs. Asynchronous events, Change Data Capture (CDC), and data duplication patterns.
23 Message Queues in System Design Asynchronous task processing, spike absorption, decoupling producers/consumers, and backpressure.
24 Database Design for Systems Relational vs. Document vs. Key-Value vs. Graph databases, indexing strategies, and normalization tradeoffs.
25 Database Replication Single-Leader, Multi-Leader, and Leaderless (Dynamo-style) replication, replication lag, and failover.
26 Database Sharding & Partitioning Horizontal sharding, partition keys, range vs. hash sharding, cross-shard queries, and re-sharding strategies.

Part 4: Interfaces, Reliability & Fault Tolerance

# Guide Primary Topics Covered
27 Interface & Contract Design API contracts, schema evolution, backwards compatibility, and Consumer-Driven Contracts (Pact).
28 REST APIs in System Design Resource URI modeling, HTTP methods, status codes, filtering/sorting, and idempotency in REST.
29 Idempotency in Distributed Systems Idempotency keys, duplicate request deduplication, distributed locks, and safe payment processing.
30 Reliability and Resiliency Availability metrics (99.999% "five nines"), MTTR, MTBF, redundancy, and disaster recovery architectures.
31 Fault-Tolerant System Design Graceful degradation, bulkheads, timeouts, fallback mechanisms, and chaos engineering principles.
32 Resilient Retries & Circuit Breakers Exponential backoff with full jitter, circuit breaker states (Closed, Open, Half-Open), and avoiding retry storms.
33 Secure System Design Threat modeling (STRIDE), Zero Trust architecture, least privilege, encryption at rest/in transit, and defense-in-depth.
⌂ All Guides