All 38 lessons in curriculum order, grouped by track. Each lesson pairs deep-dive questions with interactive diagrams and a quiz, and ends with a hands-on challenge.
Start here. What system design actually is, the vocabulary you need before anything else makes sense, and the four things an interviewer is quietly grading while you talk.
14 min · 4 questions · beginner
The arithmetic that turns a vague brief into a concrete architecture. Learn to size QPS, storage and bandwidth in under two minutes - and to know instantly whether a design is plausible.
16 min · 4 questions · beginner
The three properties every interviewer probes, made precise. How availability maths actually composes, why reliability is not the same thing, and how to spot a single point of failure in any diagram.
15 min · 3 questions · beginner
Everything that happens between a user typing a URL and bytes arriving - and why each hop is a place where latency and failure live.
16 min · 3 questions · beginner
The API is the contract every other decision has to live with. How to choose a protocol, design endpoints that survive five years of change, and get pagination and idempotency right.
17 min · 3 questions · intermediate
Four ways to push data to a client, the scaling cost of each, and how to handle the hard part - a million long-lived connections that all reconnect at once.
15 min · 2 questions · intermediate
Why one query returns in 2 ms and an identical-looking one takes 40 seconds. Indexes from first principles, and the storage-engine choice that decides whether your database prefers reads or writes.
16 min · 3 questions · intermediate
Stop asking 'SQL or NoSQL'. Ask what your access patterns are, then let the answer pick the store - with a defensible reason you can say in one sentence.
15 min · 2 questions · intermediate
The concurrency bugs that only appear in production. What each isolation level actually prevents, why the default is weaker than you think, and how to pick locking strategy.
16 min · 2 questions · advanced
How one database becomes many. Replication for read scale and availability, sharding for write scale, and the operational traps in both.
17 min · 2 questions · advanced
The single highest-leverage component in most systems, and the one with the most ways to go subtly wrong. Patterns, eviction, invalidation and the failure modes that cause outages.
17 min · 3 questions · intermediate
The cheapest performance improvement available to any global product. How CDNs work, the HTTP headers that control them, and how to invalidate content across hundreds of locations.
14 min · 2 questions · intermediate
How a single server becomes a fleet. Why statelessness is the precondition for everything, and the ordered sequence of moves that takes a system from one box to millions of users.
14 min · 1 question · beginner
Which algorithm to pick and why it matters more than you think. Plus the operational half nobody prepares for: health checks, connection draining and retry amplification.
15 min · 2 questions · intermediate
Why `hash(key) % N` breaks catastrophically when N changes, and the ring that fixes it. The algorithm behind Cassandra, DynamoDB, Memcached clients and every sharded cache.
14 min · 1 question · advanced
The most misquoted theorem in the industry. What CAP really says, why the interesting trade-off happens when there is no partition, and how to classify real systems.
14 min · 1 question · advanced
The spectrum between 'always correct' and 'always fast'. Which guarantee each model gives, how quorums work, and how to resolve conflicts when two writers disagree.
16 min · 1 question · expert
How a group of unreliable machines agrees on anything. Raft in plain language, why split brain is the danger, and why most distributed locks are quietly broken.
15 min · 2 questions · expert
What to do when one operation must span two systems. Why 2PC is usually the wrong answer, how sagas work, and why exactly-once delivery is impossible but exactly-once processing is not.
16 min · 2 questions · expert
Queues and logs look similar and behave completely differently. Which to reach for, how backpressure actually works, and what to do with messages that will never succeed.
15 min · 1 question · intermediate
How Kafka actually stores and delivers data, why partitions are the unit of both parallelism and ordering, and the operational realities - rebalances, lag and hot partitions.
15 min · 1 question · advanced
The most over-answered question in system design. When splitting genuinely helps, why most microservice migrations fail, and how to defend keeping the monolith.
15 min · 1 question · advanced
Where cross-cutting concerns live once you have more than one service. What belongs in the gateway, what belongs in the mesh, and when a BFF earns its keep.
13 min · 1 question · intermediate
Three related patterns that are constantly conflated. What each actually gives you, what each costs, and why event sourcing is far more expensive than it looks.
15 min · 2 questions · expert
Everything fails eventually. The discipline is deciding in advance how it fails - which features degrade, which stay up, and how much data you are willing to lose.
15 min · 1 question · advanced
Four algorithms, one correct default, and the hard part nobody mentions: enforcing a global limit across fifty servers without a round trip on every request.
15 min · 1 question · advanced
You cannot operate what you cannot see. What each signal is for, why high-cardinality metrics will bankrupt you, and how to alert on things users actually notice.
14 min · 1 question · intermediate
The security decisions an interviewer expects you to raise unprompted: how users authenticate, how services trust each other, where secrets live, and what a breach costs you.
15 min · 2 questions · advanced
The classic warm-up question. Deceptively simple functionally, and a perfect vehicle for ID generation, extreme read/write skew and cache design.
16 min · 2 questions · intermediate
The canonical fan-out problem. Why neither pure push nor pure pull works at scale, and how the hybrid model that every major platform actually uses is derived.
18 min · 2 questions · advanced
Real-time messaging at scale. Connection management, per-conversation ordering, guaranteed delivery across flaky mobile networks, and group fan-out.
17 min · 2 questions · advanced
Push, email and SMS at scale. Provider failover, preference enforcement, deduplication and the digest logic that stops you spamming your own users.
15 min · 2 questions · intermediate
The largest-scale case study there is. Transcoding pipelines, HLS and DASH, why 95%+ of bytes must never touch your origin, and counting views at a billion a day.
17 min · 2 questions · expert
Real-time geospatial matching. How to index a moving fleet, find nearby drivers in milliseconds, and run a matching algorithm that is correct under heavy concurrency.
16 min · 2 questions · expert
Crawling billions of pages politely, deduplicating near-identical content, and building an inverted index that answers a query in under 200 ms.
17 min · 2 questions · expert
A script you can run on any prompt. Six steps, a time budget for each, and the exact sentences that move you between them.
15 min · 1 question · intermediate
System design has no right answers, only defended ones. Every recurring decision, what you gain, what you pay, and the sentence that makes it sound deliberate.
13 min · 1 question · advanced
What actually gets written on the feedback form. The behaviours that map to each level, the rubric dimensions, and how to signal the level you are targeting.
13 min · 1 question · advanced