System Design Tutorial & Interview Prep
Learn system design from first principles and finish ready for the interview. 38 lessons and 71 deep-dive questions across 11 tracks - estimation, databases, caching, load balancing, distributed systems, messaging and 7 full case studies. With 39 interactive diagrams and simulators, because some of this cannot be learned from prose.
- Lessons
- 38
- Deep-dive questions
- 71
- Interactive visuals
- 39
- Case studies
- 7
Progress is saved in this browser only - no account, no tracking, nothing leaves your device.
Eleven tracks, one path
Ordered so each track builds on the last - primitives, then components, then theory, then whole systems. Skip ahead freely; every lesson stands on its own.
Foundations & First Principles
3 lessons · 11 questions
What a system design interview actually measures, the vocabulary, and the back-of-envelope arithmetic everything else rests on.
Start trackNetworking & API Design
3 lessons · 8 questions
DNS, TCP vs UDP, HTTP/2 and 3, TLS, REST vs gRPC vs GraphQL, and how to push data to a client in real time.
Start trackDatabases & Storage
4 lessons · 9 questions
Indexes, B-trees vs LSM trees, transactions and isolation levels, SQL vs NoSQL, sharding and object storage.
Start trackCaching & Content Delivery
2 lessons · 5 questions
Cache-aside vs write-through, eviction policies, invalidation, stampedes, CDNs and the hot-key problem.
Start trackScaling & Load Balancing
3 lessons · 4 questions
Vertical vs horizontal growth, load-balancing algorithms, statelessness, autoscaling and consistent hashing.
Start trackDistributed Systems Theory
4 lessons · 6 questions
CAP and PACELC, replication, consensus and leader election, clocks and ordering, idempotency and exactly-once.
Start trackMessaging, Queues & Streams
2 lessons · 2 questions
Queues vs logs, Kafka partitions and consumer groups, delivery semantics, backpressure and dead-letter design.
Start trackArchitecture Patterns
3 lessons · 4 questions
Monolith vs microservices, API gateways, saga and outbox, CQRS and event sourcing, and multi-tenancy.
Start trackReliability, Security & Observability
4 lessons · 5 questions
SLOs and error budgets, timeouts and circuit breakers, rate limiting, auth, and the three pillars of observability.
Start trackDesign Case Studies
7 lessons · 14 questions
Full worked designs - URL shortener, news feed, chat, rate limiter, video streaming, ride hailing and search.
Start trackThe Interview Playbook
3 lessons · 3 questions
The 45-minute script, whiteboard technique, how you are levelled, and recovering when you get stuck.
Start trackBuilt to be understood, not memorised
You cannot memorise system design - there are too many systems. You can learn the components, the arithmetic and the trade-offs.
Concepts you can touch, not just read
39 interactive diagrams and live simulators built into the lessons. Break a server and watch least-connections send it more traffic. Add a node to a hash ring and see exactly which keys move. Reproduce the fixed-window rate-limit bug yourself.
Numbers before boxes
Every design starts with arithmetic. Capacity calculators, latency ladders and availability composition are built in, so you learn to reach an order of magnitude in two minutes and then use it to rule designs out.
Beginner to advanced, in order
Starts at 'what is a load balancer' and ends at consensus, sagas and exabyte-scale video delivery. Each track builds on the last, and every lesson stands alone if you need to skip ahead.
A mock interview that mirrors the real thing
A full 45-minute design session with a six-phase timer that pushes you through clarify, estimate, design and deep dive - plus a rapid recall drill and an honest self-assessment checklist.
The full curriculum
38 lessons across 11 tracks. Search by topic, company, or the exact question you were asked.
Foundations & First Principles
What a system design interview actually measures, the vocabulary, and the back-of-envelope arithmetic everything else rests on.
What Is System Design? A Beginner's Introduction
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.
Back-of-the-Envelope Estimation for System Design
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.
Scalability, Availability and Reliability Explained
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.
Networking & API Design
DNS, TCP vs UDP, HTTP/2 and 3, TLS, REST vs gRPC vs GraphQL, and how to push data to a client in real time.
How the Internet Works: DNS, TCP, TLS and HTTP
Everything that happens between a user typing a URL and bytes arriving - and why each hop is a place where latency and failure live.
API Design: REST vs gRPC vs GraphQL
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.
Real-Time Communication: Polling, SSE and WebSockets
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.
Databases & Storage
Indexes, B-trees vs LSM trees, transactions and isolation levels, SQL vs NoSQL, sharding and object storage.
Database Indexes and Query Performance
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.
SQL vs NoSQL: Choosing the Right Database
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.
ACID Transactions and Isolation Levels
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.
Database Replication and Sharding
How one database becomes many. Replication for read scale and availability, sharding for write scale, and the operational traps in both.
Caching & Content Delivery
Cache-aside vs write-through, eviction policies, invalidation, stampedes, CDNs and the hot-key problem.
Caching Strategies and Eviction Policies
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.
CDNs and Edge Caching
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.
Scaling & Load Balancing
Vertical vs horizontal growth, load-balancing algorithms, statelessness, autoscaling and consistent hashing.
Horizontal vs Vertical Scaling and Stateless Design
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.
Load Balancing Algorithms and Health Checking
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.
Consistent Hashing Explained
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.
Distributed Systems Theory
CAP and PACELC, replication, consensus and leader election, clocks and ordering, idempotency and exactly-once.
CAP Theorem and PACELC, Properly Explained
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.
Consistency Models and Replication Strategies
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.
Consensus, Leader Election and Distributed Locks
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.
Distributed Transactions, Sagas and Exactly-Once
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.
Messaging, Queues & Streams
Queues vs logs, Kafka partitions and consumer groups, delivery semantics, backpressure and dead-letter design.
Message Queues vs Event Streams
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.
Kafka Architecture and Delivery Semantics
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.
Architecture Patterns
Monolith vs microservices, API gateways, saga and outbox, CQRS and event sourcing, and multi-tenancy.
Monolith vs Microservices: Making the Call
The most over-answered question in system design. When splitting genuinely helps, why most microservice migrations fail, and how to defend keeping the monolith.
API Gateways, Service Mesh and BFF
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.
Event-Driven Architecture, CQRS and Event Sourcing
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.
Reliability, Security & Observability
SLOs and error budgets, timeouts and circuit breakers, rate limiting, auth, and the three pillars of observability.
Designing for Failure: Bulkheads, Degradation and Chaos
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.
Rate Limiting Algorithms and Distributed Throttling
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.
Observability: Logs, Metrics and Distributed Tracing
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.
Security in System Design
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.
Design Case Studies
Full worked designs - URL shortener, news feed, chat, rate limiter, video streaming, ride hailing and search.
Design a URL Shortener (TinyURL / bit.ly)
The classic warm-up question. Deceptively simple functionally, and a perfect vehicle for ID generation, extreme read/write skew and cache design.
Design a News Feed (Twitter / Facebook Timeline)
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.
Design a Chat System (WhatsApp / Slack)
Real-time messaging at scale. Connection management, per-conversation ordering, guaranteed delivery across flaky mobile networks, and group fan-out.
Design a Notification System
Push, email and SMS at scale. Provider failover, preference enforcement, deduplication and the digest logic that stops you spamming your own users.
Design a Video Streaming Platform (YouTube / Netflix)
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.
Design a Ride-Hailing System (Uber / Lyft)
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.
Design a Web Crawler and Search Index
Crawling billions of pages politely, deduplicating near-identical content, and building an inverted index that answers a query in under 200 ms.
The Interview Playbook
The 45-minute script, whiteboard technique, how you are levelled, and recovering when you get stuck.
The System Design Interview Framework
A script you can run on any prompt. Six steps, a time budget for each, and the exact sentences that move you between them.
The Trade-off Cheat Sheet
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.
How You Are Levelled and Evaluated
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.
Practice tools
Reading is not preparation. These turn the material into something you can produce under pressure.
Interactive toolkit
Every simulator in one place - capacity calculator, hash ring, rate limiter, cache eviction, quorums, CDN routing and more.
OpenMock interview
A full 45-minute design session with a six-phase timer, interviewer probes and an honest self-assessment.
OpenPattern library
Reusable patterns with the problem each solves, when to use it and - the part that scores - when not to.
Open10-week study plan
Four phases from foundations to full case studies, with a weekly goal and a concrete deliverable.
OpenFlashcard drill
All 71 questions as recall cards. Filter by track, flip with the space bar, grade yourself.
OpenGlossary
Every term with a definition and - more usefully - the specific angle an interviewer will push on.
OpenFrequently asked questions
Is this system design course really free?
Yes. Every lesson, interactive simulator, quiz, flashcard and the mock interview are completely free with no sign-up. Your progress is stored in your browser's local storage and never leaves your device.
I have never done system design before. Is this too advanced?
No - it starts from the beginning. The first lesson explains what system design actually is, defines the vocabulary, and walks through the standard components before any architecture is drawn. Levels are marked from Beginner to Expert so you always know what you are stepping into.
How long does it take to complete?
Roughly 10 hours of reading across 38 lessons, plus the hands-on challenges. The included 10-week plan schedules 6–10 hours a week; you can compress it to five weeks at 15+ hours a week.
What makes this different from a list of system design questions?
Three things. Every answer includes the derivation and the trade-off, not just the conclusion. The concepts you cannot learn from prose - consistent hashing, quorums, rate limiting, cache eviction - are interactive simulators you manipulate directly. And every lesson ends with the follow-up questions an interviewer will actually ask next.
Does it cover the classic design questions?
Yes - there are 7 full worked case studies: URL shortener, news feed, chat system, notification system, video streaming, ride hailing, and a web crawler with a search index. Each one is a complete design with requirements, estimation, architecture and the failure discussion.
Which roles is this for?
Backend, full-stack, platform, infrastructure and senior engineering interviews at any company that runs a system design round. It is also useful outside interviews - the material is the same whether you are being assessed or actually building the system.
Do I need to know a specific programming language?
No. Code examples are used only where they clarify a concept, and they are in Python, SQL, JavaScript or configuration files. You can follow every lesson without writing any code, though the hands-on challenges are where the material sticks.
Start where you are weakest
Run a 45-minute design session right now. Whatever you cannot justify out loud is your first lesson.
Curriculum
- Design a URL Shortener (TinyURL / bit.ly)2 Q · 16 min
- Design a News Feed (Twitter / Facebook Timeline)2 Q · 18 min
- Design a Chat System (WhatsApp / Slack)2 Q · 17 min
- Design a Notification System2 Q · 15 min
- Design a Video Streaming Platform (YouTube / Netflix)2 Q · 17 min
- Design a Ride-Hailing System (Uber / Lyft)2 Q · 16 min
- Design a Web Crawler and Search Index2 Q · 17 min