Learn the building blocks, then design a system
This course combines fundamentals, practical distributed-systems reasoning and end-to-end design workshops. Use the sidebar as your syllabus. New to system design? Start with the four-lesson beginner path: how systems grow from one server to millions of users, the building blocks explained, estimation practice and the interview playbook. Already comfortable with the basics? Start with requirements and estimates, or find a concept in the index below.
The curriculum develops 40 core concepts alongside networking, security, consensus, observability and production recovery. System design is an open-ended field; this is a substantial interview and engineering foundation, not a claim that every possible specialization is covered.
Study in this order
| Phase | Lessons | Produce this evidence |
|---|---|---|
| Start here (beginners) | How systems grow; building blocks; estimation practice; interview playbook | One app scaled step by step on paper, and a step-by-step interview plan |
| Scope and requests | Fundamentals; networking; API design; identity | Requirements, capacity estimate and an authorized request trace |
| Data and scale | Database scaling; caching; scalability; storage/search/geo | Schema, indexes, cache policy and partition key |
| Events and coordination | Queues; Kafka; real-time/webhooks; transactions/CDC; consensus | Delivery contract and crash/recovery timeline |
| Operating systems at scale | Microservices; reliability; observability | SLO, overload policy and tested recovery plan |
| Apply and review | Worked designs; design workshops | Ten designs with alternatives and failure cases |
| Case studies | URL shortener, Twitter timeline, web crawler, search query cache, social graph, sales ranking, personal finance, chat, video streaming, file sync, ride hailing, notifications, typeahead | Each design talked through end to end in 45 minutes |
A four-week example: spend week one on request/identity/data basics, week two on cache/partition/storage, week three on events/correctness/coordination, and week four on operations and timed workshops. Choose pace by your prior knowledge rather than treating four weeks as a guarantee.
Interactive experiments
- Kafka partition and consumer lab: publish, commit, crash, replay and stop brokers.
- Consensus experiment: remove voters and observe the majority boundary.
- Bloom filter experiment: observe shared bits and probable membership.
The simulations are explicitly simplified browser models, not production benchmarks or live clusters.
Find a concept
Use this index to find the lesson that develops each concept. Related topics are linked within the lessons.
| Concept | Read |
|---|---|
| APIs | APIs |
| API Gateways | API Gateways |
| REST vs GraphQL | REST vs GraphQL |
| JWTs | JWTs |
| Webhooks | Webhooks |
| Long Polling vs WebSockets | Long Polling vs WebSockets |
| Load Balancing | Load Balancing |
| Proxy vs Reverse Proxy | Proxy vs Reverse Proxy |
| CDN | CDN |
| Rate Limiting | Rate Limiting |
| Caching | Caching |
| Distributed Caching | Distributed Caching |
| Caching Strategies | Caching Strategies |
| Cache Eviction Policies | Cache Eviction Policies |
| Consistent Hashing | Consistent Hashing |
| SQL vs NoSQL | SQL vs NoSQL |
| ACID Transactions | ACID Transactions |
| Database Index | Database Index |
| Database Sharding | Database Sharding |
| Database Scaling | Database Scaling |
| Data Replication | Data Replication |
| Data Redundancy | Data Redundancy |
| Change Data Capture | Change Data Capture |
| CAP Theorem | CAP Theorem |
| Strong vs Eventual Consistency | Strong vs Eventual Consistency |
| Scalability | Scalability |
| Availability | Availability |
| Single Point of Failure | Single Point of Failure |
| Latency vs Throughput | Latency vs Throughput |
| Stateful vs Stateless | Stateful vs Stateless |
| Message Queues | Message Queues |
| Circuit Breaker | Circuit Breaker |
| Idempotency | Idempotency |
| Fault Tolerance | Fault Tolerance |
| Disaster Recovery | Disaster Recovery |
| Distributed Locking | Distributed Locking |
| Bloom Filters | Bloom Filters |
| Concurrency vs Parallelism | Concurrency vs Parallelism |
| Batch vs Stream Processing | Batch vs Stream Processing |
| Geohashing | Geohashing |
Advanced topics
| Area | Additional coverage |
|---|---|
| Communication | DNS/TCP/TLS/HTTP, connection reuse, SSE, gRPC, reconnect cursors, backpressure |
| Correctness | Isolation anomalies, optimistic concurrency, outbox/inbox, CDC, sagas, 2PC, CQRS/event sourcing |
| Coordination | Quorums, Raft, election epochs, logical clocks, leases/fencing, split brain and CRDT boundaries |
| Storage | B-trees/LSM/WAL, inverted indexes, object storage, compaction, approximate membership, spatial candidates |
| Security | OAuth/OIDC/PKCE, token rotation, revocation, CSRF/XSS, tenant isolation and service identity |
| Operations | Deadline budgets, retry amplification, bulkheads, admission control, SLOs, traces, profiles and recovery drills |
| Architecture | Monolith vs services, discovery, service mesh, control/data planes, rollout safety and cost |
For specialized work, continue into database implementation, formal protocol verification, GPU/ML infrastructure, real-time media, regulatory security or domain-specific systems. The appropriate depth depends on the role.
Production deep dives
These lessons extend topics that previously appeared only as brief introductions. Work through them after the operations lessons and before the final workshops.
| Lesson | What you will work through |
|---|---|
| Data lifecycle and migrations | ID choices, collision math, compatible deployments, backfills, shard movement and deletion |
| Multi-region design | Ownership, replication contracts, read-your-writes, conflict repair, fencing and failback |
| Durable workflows and event sourcing | Persistent steps, cancellation, compensation, CQRS, snapshots and replay-safe effects |
| Stream processing and analytics | Event time, windows, watermarks, lateness, joins, checkpoints and approximate aggregation |
| Storage and search deep dive | Amplification, MVCC cleanup, compaction, vector/hybrid search and storage repair |
| Multi-tenancy and isolation | Tenant keys, access boundaries, fair queues, cells, quotas and usage metering |
| Capacity, SLOs and cost | Backlog drain, fan-out tails, error-budget math, autoscaling and failure headroom |
| Booking and payments | Complete schema/API design, reservation races, payment reconciliation and failure traces |
The course now has 28 ordered lessons. Exercises use stated hypothetical inputs, not measured capacity claims. For each deep dive, write down a state invariant, a failure timeline and the operational metric that reveals a broken assumption.
Review before an interview
Take one requirement and explain its effect on API, data, latency and failure behavior. Calculate one capacity number with assumptions. Walk through a crash between each pair of writes. Explain who owns retries, where duplicate prevention is atomic and how the system recovers. Finish by naming the simplest viable design and what would justify the next layer of complexity.

