Course and AI tutor
System design, from zero, in plain English.
125 lessons in 19 modules. Each lesson uses only ideas you have already met. No gaps.
Every lesson is free to read. No account, no credit card. The AI tutor is what you sign up for (20 questions a day, free).
- Lessons
- 125
- Modules
- 19
- Reading time, all lessons
- 44 hours, about
- Fast track
- 34 lessons, about a week
How it is written
Three rules, written down
Every lesson is written to these rules. They are the reason the course is easy to follow.
01
Bottom up
A lesson never uses an idea you have not met.
Lesson 31 is about caching. It needs 4 lessons first. They come earlier in the course, so when you reach it, nothing in it is new.
See lesson 31 in the syllabus- 4How good is good enough: uptime and speed
- 15Storage, bandwidth and how many servers
- 17SQL or NoSQL, and which kind
- 20Indexes and reading a query plan
- 31Caching basics: hit, miss, TTL, hit rate
02
Very easy English
Short sentences. Common words. Every term explained.
Many engineers read English as a second language. The course is written for them, not for native speakers who already know the words.
See the reading time of every lesson03
Complete
One idea, taught fully, so you can answer in an interview.
Not a thin summary. Each lesson has the reason, the idea, a worked example, the trade-offs, the common mistakes, and a check with answers.
See the case studies21 case studies
- 38URL shortener
- 57Rate limiter for many servers
- 70Payment system
- 77Chat
- 78News feed
- 81Ride-hailing and food delivery
- and 15 more
Inside a lesson
How one lesson goes
All 125 lessons have the same nine parts, in the same order. So you always know where you are, and what to do next.
Some lessons also end with a one-page summary card. Open a part to see what it is for.
01Why interviewers ask this
A short, real situation. You see why the topic matters, and how a weak answer and a strong answer sound.
02The idea in plain words
Every new word is explained the first time it appears. A small everyday picture first, then the idea.
03Pause and predict
A question before the answer. You guess first. A guess you made yourself sticks better than an answer you read.
04Worked example
One example with every sum shown, step by step. Made-up numbers are marked as assumptions, so you know they are for teaching.
05Trade-offs
What each choice gives you, what it costs, and when you would change it. This is what an interviewer listens for.
06Common misconceptions
Mistakes people really make, and why each one is wrong.
07How to say it in the interview
Two short sentences you can say out loud. For spoken rounds, where clear words matter.
08Check your understanding
A few questions, some with sums, to test yourself before you move on.
09Answers
Full worked answers, so you can mark yourself and see where you went wrong.
The syllabus
All 125 lessons, in order
Search by a word, or filter by level. Every lesson opens right now, free, with no account.
125 lessons in 19 modules
01Start here: how the round works6 lessons2 h
- 1
What a system design interview really judges: not one right answer, but good choices that fit the needs, with their costs said out loud.
20 minRead free - 2
How a design round runs: six steps in 45 minutesFast track
The six steps of a design round, a clock for 45 minutes, one small design from start to end, and what each level should do.
23 minRead free - 3
Requirements: what to ask firstFast track
How to turn a short, open question into a list of needs with numbers, and what reliability, scalability and maintainability mean in plain words.
22 minRead free - 4
How good is good enough: uptime and speedFast track
What 99.9 percent means in hours of downtime, what p50, p95 and p99 mean for speed, and why an average hides slow users.
22 minRead free - 5
Reading and drawing architecture diagrams
What a box and an arrow mean, how to put numbers on them, and how to read a drawing to find the part that gets too busy first.
12 minRead free - 6
Say it clearly: trade-off sentences and spoken EnglishFast track
The three-part trade-off sentence, simple phrases for each moment of a spoken round, and how to think aloud.
21 minRead free
- 1
02Web and API basics7 lessons1 h 36 min
- 7
What happens in one web request
The steps from typing a web address to seeing the page: DNS, a TCP connection, an HTTP request and response, plus UDP, redirects and cookies.
12 minRead free - 8
DNS: how a request finds your server
How DNS records turn a name into an address, how the TTL decides how fast a change reaches users, and how geo routing sends each user to a nearby server.
12 minRead free - 9
REST and CRUD: resources, methods, status codes
How a REST API names things with URLs, what GET, POST, PUT, PATCH and DELETE mean, which are idempotent, and which status code to return.
12 minRead free - 10
API errors and paging through results
How to shape an error so a program can read it, why a long list is returned in pages, offset against cursor paging, and how an OpenAPI file documents the API.
12 minRead free - 11
Changing an API without breaking callers
Which API changes are safe, which break callers, and how versions, deprecation dates and a slow move from the old field to the new one keep old apps working.
12 minRead free - 12
Three ways for one program to call another, what each is good at and what it costs, how JSON and Protobuf differ, and how to pick by who calls whom.
24 minRead free - 13
What the cloud is in plain words: rented compute, storage and network, paid for by use, and the same three blocks at AWS, Azure and Google Cloud.
12 minRead free
- 7
03Estimation3 lessons1 h 10 min
- 14
From users to requests per secondFast track
How to turn daily users into requests per second, with a busiest-time factor and a read to write split, plus the sizes, times and powers of two worth knowing.
24 minRead free - 15
Storage, bandwidth and how many serversFast track
How to work out how much data you store, how much data moves each second, how many servers and how much memory you need, and what it costs each month.
24 minRead free - 16
Estimation drills at Indian scale
Three timed drills on Indian events, UPI payments on the 1st, a live cricket final and a train booking window at 10 am, using one routine for requests, data, writes and servers.
22 minRead free
- 14
04Databases: first steps9 lessons3 h 22 min
- 17
SQL or NoSQL, and which kindFast track
How to choose a database from the way your app uses its data: the five kinds of database, what each is good at, and what each costs.
24 minRead free - 18
Data modelling: tables, relationships, normal forms
How to turn requirements into tables: find the entities, decide how they link, draw them, and keep each fact in one place with the first three normal forms.
24 minRead free - 19
Design tables for your queries
How to design tables from the questions the app asks: count the rows each query reads, copy a fact on purpose when a query reads too many, and keep each copy right.
24 minRead free - 20
Indexes and reading a query planFast track
Why an index makes a query fast, how a B-tree and a composite index work, when an index hurts, and how to read EXPLAIN to find out what the database really does.
25 minRead free - 21
Transactions: ACID and isolation levelsFast track
What a transaction promises (ACID), how isolation levels decide what two users doing things at the same time can see, and the bugs that appear when you choose the wrong level.
22 minRead free - 22
Locking: stop double booking and oversellingFast track
How to make sure two buyers cannot get the same seat or the last item: atomic updates, locks, version checks, unique constraints, and seat holds that expire.
23 minRead free - 23
Unique IDs: UUID, ULID, Snowflake, sequencesFast track
How to give every row a unique ID: database counters, random UUIDs, time-ordered IDs, Snowflake IDs and counter ranges, and which one to use for which job.
24 minRead free - 24
Object storage and pre-signed uploads
Why photos and videos do not belong in database rows, how object storage keeps them, and how a phone uploads big files straight to storage with a pre-signed URL, in parts that can resume.
24 minRead free - 25
Changing a table without downtime
How to change a big table while the app keeps running: add the new column first, move the data in small steps, and remove the old column last.
12 minRead free
- 17
05Scaling one service5 lessons1 h 33 min
- 26
Scale up or scale out, and why servers must be stateless
Two ways to add capacity, a bigger machine or more machines, what each one costs, and why more machines work only when no server keeps a user's data in its own memory.
21 minRead free - 27
Cheap wins first: batching, compression, doing less
Before you add servers, remove the waste: group small jobs into one, compress text, and stop doing work that nobody needs.
12 minRead free - 28
Load balancingFast track
What a load balancer does, how it picks a server, how it finds a broken server, and why the load balancer itself must not be a single point of failure.
24 minRead free - 29
Connection pools and the database connection limit
Why servers keep a small set of open links to the database, why the database allows only so many, and how to check that servers times pool size stays under the limit.
24 minRead free - 30
API gateway, reverse proxy and BFF
What a reverse proxy, an API gateway and a backend for frontend each do, what each one costs, and when a plain load balancer is enough.
12 minRead free
- 26
06Caching and CDN8 lessons3 h
- 31
Caching basics: hit, miss, TTL, hit rateFast track
Why a cache protects the database, and how to estimate how much it helps with simple arithmetic.
24 minRead free - 32
Cache-aside, write-through, write-backFast track
Who updates the cache when data changes: three ways to do it, what each one costs, and what can go wrong with each.
24 minRead free - 33
What to throw out: LRU, LFU and cache size
What a cache removes when its memory is full, how the main rules (first in first out, random, least recently used, least frequently used) differ, and how to choose the size of a cache.
22 minRead free - 34
Keeping cached data fresh (invalidation)
How old cached data can get, and the ways to keep it fresh: wait for the TTL, delete the entry when the data changes, or change the key. What each way costs and how to measure stale reads.
23 minRead free - 35
When the cache is empty and everyone asks at once (stampede)Fast track
What happens to the database when the cache is empty or one popular entry expires, and how warm-up, TTL jitter and request coalescing keep the database alive.
24 minRead free - 36
CDN: serving files from near the user
How a CDN keeps copies of your files in many cities, which files belong there and which do not, how to change a file safely, and how it keeps a sudden crowd away from your own servers.
24 minRead free - 37
Redis beyond a cache: counters, leaderboards, simple locksFast track
Three small jobs for Redis besides caching: an atomic counter, a leaderboard with a sorted set, and a lock with a time limit, with the limits of each.
12 minRead free - 38
Case study: URL shortenerFast track
Design a URL shortener from numbers: estimate the load, make the short code, answer a redirect with a cache and an index, and find the limit where one database is no longer enough.
27 minRead free
- 31
07Copies and splits of data8 lessons2 h 55 min
- 39
Replication: leader and followersFast track
How a database keeps copies of its data on other servers, what the copies are for, and what happens when the leader waits for them or does not.
24 minRead free - 40
Why do I see old data after saving? (replica lag)Fast track
Why a follower can show old data right after you save, how long the delay lasts, how to make users see their own changes, and the first plain meaning of eventual.
24 minRead free - 41
Failover: what happens to writes in flight
What happens when the leader dies: how a follower is promoted, which writes can be lost, how long writes stop, and how two leaders at once do harm.
24 minRead free - 42
Why a follower cannot undo a DELETE, how a backup plus the log restores data to one chosen moment, and what RPO and RTO mean.
12 minRead free - 43
Sharding: splitting data across serversFast track
How to split one database over several servers: the shard key, range, hash and directory, what a bad key costs, and why adding a shard is hard.
24 minRead free - 44
Adding servers without moving all the data (consistent hashing)Fast track
How a ring of hash positions lets you add or remove a server and move only a small share of the data, and how virtual nodes make the load even.
23 minRead free - 45
When one key gets all the traffic (hot partition)
Why one very popular key can overload one shard whatever the number of shards, how to find it, and how to split it, copy it or cache it.
20 minRead free - 46
How databases write fast: LSM trees and Bloom filters
How a write-heavy database stores data: a log and a table in memory, sorted files that never change, merging in the background, and a Bloom filter that says a key is definitely not in a file.
24 minRead free
- 39
08Consistency and coordination7 lessons2 h 24 min
- 47
CAP and consistency levels: what you give up when the network breaksFast track
The levels of consistency from strong to eventual, what a network partition is, what the CAP theorem really says, and the cost in milliseconds that PACELC adds for normal times.
24 minRead free - 48
Agreeing with the majority (quorums)
How a write and a read each ask some of the copies, why R + W > N makes a read meet the newest write, and how to choose R and W for fast reads, fast writes or failures.
12 minRead free - 49
Whose clock is right? Putting events in order
Why two servers never agree on the time, why sorting by timestamp can put a reply before its question, and how per-key sequence numbers and logical clocks give a safe order.
24 minRead free - 50
When many places accept writes: conflicts
What happens when more than one server accepts writes for the same data: how a conflict is found, and four ways to settle it, from last write wins to merge rules that always work.
24 minRead free - 51
Only one worker at a time: locks, leases, fencing tokens
Why a lock shared by many servers is hard to make safe: the lease that ends while its holder is paused, clocks and failed lock servers, and the fencing token that lets the data reject a stale holder.
22 minRead free - 52
Leader election and consensus in plain words
How a group of servers chooses one leader for each term: the Raft idea of terms, votes and a majority, why an old leader cannot save changes, what it costs, and when to use a ZooKeeper-style tool instead of writing it yourself.
12 minRead free - 53
Case study: Distributed cache and key-value store
Design a store that keeps keys on many servers: place keys on a ring, keep three copies, use quorums, store data on each server so that writes are fast, and see what changes when it is only a cache.
26 minRead free
- 47
09Failing safely4 lessons1 h 28 min
- 54
Timeouts, retries, backoff and jitterFast track
How to set a time limit on every call, when to try again, how long to wait between tries, and how retries can turn a small problem into a storm.
24 minRead free - 55
Stop calling a broken service (circuit breaker, bulkhead)
How a circuit breaker stops calls to a service that is failing, how a bulkhead gives each service its own workers, and why one slow service must not use all of them.
12 minRead free - 56
Rate limiting: token bucket, leaky bucket, sliding windowFast track
How to limit the requests one user can send, with five counting methods (fixed window, sliding window log, sliding window counter, token bucket, leaky bucket) and what each one costs.
24 minRead free - 57
Case study: Rate limiter for many serversFast track
How to make a rate limit hold when a client's requests reach many servers: shared counters in Redis, atomic steps, speed and size, quotas, and what an attacker does.
28 minRead free
- 54
10Queues and events8 lessons2 h 50 min
- 58
Queues: what they solve, and what must stay in the requestFast track
How a queue moves slow work out of the user's request, how to choose what moves and what stays, and how to do the arithmetic for a growing backlog.
23 minRead free - 59
Queue, log or pub/sub (RabbitMQ-style vs Kafka-style)
The difference between a queue that removes messages and a log that keeps them, with partitions, offsets and consumer groups, event-driven design, and how to choose.
24 minRead free - 60
Will my message arrive once, twice or never?
Why a message can be lost or repeated, what at-most-once, at-least-once and exactly-once mean, and how the order of the acknowledgement and the work decides which one you get.
20 minRead free - 61
Doing it twice should be safe (idempotency)Fast track
How to make a request or a message safe to receive twice: idempotency keys, a table of seen IDs with a unique constraint, and consumers that skip repeats.
24 minRead free - 62
Dead-letter queues and poison messages
What to do with a message that fails every time: limit the tries, move it to a separate queue, raise an alarm, fix the cause and send it again.
12 minRead free - 63
When too much arrives: slow down, say no, or do less
What to do when more work arrives than a service can finish: bounded queues and back-pressure, load shedding by priority, and graceful degradation, with the numbers.
20 minRead free - 64
Save and announce together (outbox, CDC)
Why saving to a database and sending a message are two separate writes that can disagree, and how an outbox table or change data capture makes them agree.
24 minRead free - 65
Separate reads from writes; store events (CQRS, event sourcing)
How to give reads their own copy of the data, shaped for each screen and filled from events, and how to store every change as an event instead of the current state: when each one pays and when it is too much.
23 minRead free
- 58
11Workflows, money and bookings9 lessons3 h 37 min
- 66
How to describe an order, a payment or a booking as a list of states and a table of legal moves, so that a wrong or repeated message cannot put it in a wrong state.
12 minRead free - 67
Many steps, one undo plan (sagas)Fast track
How to finish a job that spans several services when one database transaction cannot cover it: steps with compensations, who runs the plan, and why two-phase commit is rare.
24 minRead free - 68
Ledgers and reconciliationFast track
How to keep money records that can always be explained: an append-only ledger with balanced entries, payments that stay pending until confirmed, and a daily check against the gateway's report.
24 minRead free - 69
Webhooks and third-party integrations
How to receive a webhook safely (signature, fast reply, repeats, wrong order), how to send one to many receivers, and what to read in a provider's promises.
24 minRead free - 70
Case study: Payment system (UPI, cards; wallet twist)Fast track
How to design the payment part of an app: one key for each payment, a state machine, safe callbacks, a ledger, an outbox, a daily check against the gateway, and a wallet version.
28 minRead free - 71
Case study: E-commerce checkout and flash sale
How to design checkout for an online shop (catalog, cart, stock, order, fraud check) and how to keep one hot item correct when a million people press Buy on a big sale day.
28 minRead free - 72
How to design ticket booking for trains and cinemas: seat states, a hold that expires, a waiting room for the 10 am rush, payments that finish late, and a version for hotel rooms.
28 minRead free - 73
Case study: Notification system
How to design one system that sends push, SMS and email: separate lanes for urgent and bulk messages, fan-out to 50 million users, retries, duplicate protection and per-user limits.
25 minRead free - 74
Design a job scheduler: store jobs by run time, let workers claim due jobs, handle crashed workers and repeats, make cron entries fire once, and find the point where the database is too slow.
24 minRead free
- 66
12Real-time and feeds4 lessons1 h 40 min
- 75
Polling, long polling, SSE and WebSocketsFast track
Four ways to send news from a server to a phone (polling, long polling, Server-Sent Events and WebSockets), using a live cricket score, and what an open connection costs.
23 minRead free - 76
A feed for 10 million followers: build early or on demand (fan-out)Fast track
Two ways to build a home feed (push posts into follower lists, or merge on each read) and the hybrid for accounts with millions of followers.
23 minRead free - 77
Case study: Chat (WhatsApp)Fast track
How to design a chat app: connection servers, a store-first message path, order inside each chat, receipts, offline messages and presence, with the numbers.
26 minRead free - 78
How to design the home feed of a social app: the path of a post and of a feed open, a hybrid timeline, a ranking step that can be switched off, photos on a CDN and the caches, with the numbers.
28 minRead free
- 75
13Location and search3 lessons1 h 16 min
- 79
Finding what is nearby: geohash, quadtree, H3/S2
How to answer 'restaurants near me' fast by cutting the map into cells, how geohash, quadtree, H3 and S2 do it, and why moving drivers need a different plan from fixed places.
24 minRead free - 80
Search: inverted index, ranking, Elasticsearch in practice
How a search server finds documents by words: the inverted index, how results are ranked, how an index is split into shards, and how to keep it in step with the database.
24 minRead free - 81
Case study: Ride-hailing and food delivery
How to design a ride-hailing app and a food delivery app: nearby drivers, ETA, assigning a driver without double booking, live tracking, the order lifecycle and the extra side of the kitchen, with the numbers.
28 minRead free
- 79
14Counting, pipelines and media6 lessons2 h 38 min
- 82
Counting at scale: top-K, trending, leaderboards
How to count when one counter is too busy or the items are too many: sharded counters, top-K with a count-min sketch, unique counts with HyperLogLog, trending, and leaderboards.
24 minRead free - 83
Case study: Search autocomplete
How a shopping app shows 8 suggestions while you type: a trie with the best 8 phrases on every node, scores from search logs, a trending layer, safe refresh, and serving from memory.
25 minRead free - 84
Case study: Ad-click aggregation
How to count billions of ad clicks: a fast stream for live numbers, a nightly batch for the exact bill, one-minute windows by event time, late clicks, and counting each click exactly once.
27 minRead free - 85
How a crawler fetches 100 million pages a day without hurting any site: the frontier with a queue per host, politeness and robots.txt, URL clean-up, and a Bloom filter that skips URLs it has already seen.
27 minRead free - 86
Case study: File storage and sync (Dropbox, Drive)
How a file app keeps your files on every device: chunks named by their hash, uploading only what is new, a metadata database, sync with a change journal, and conflicts kept as copies.
27 minRead free - 87
Case study: Video streaming: on demand and live (Hotstar IPL)
How to design a video app: make several sizes of each video, cut them into small files, let the phone choose the size, serve the files from a CDN, and prepare for a live match that millions join together.
28 minRead free
- 82
15Services and running it11 lessons3 h 28 min
- 88
Monolith or microservices, and where to cut
When to keep one program and when to split it into services, how to choose the boundaries, and how to move one piece at a time without a big rewrite.
24 minRead free - 89
How one service finds the current addresses of another service when copies start, stop and move: DNS, a load balancer, or a service registry, and what each one costs.
12 minRead free - 90
Multi-region: latency, failover, data residency
Why an app runs in more than one region, how a second region is used (active-passive or active-active), what a region failover costs in seconds and lost writes, and where the data may live.
24 minRead free - 91
Logs, metrics and traces: what each one tells you
What a log, a metric and a trace each tell you, the four numbers to watch on any service, and how one request is followed through many servers.
24 minRead free - 92
SLOs, error budgets and alerts
How to turn a reliability goal into a measured target, an error budget and an alert that fires when the budget is used too fast, and how a contract differs from a target.
12 minRead free - 93
Case study: Metrics and logging pipeline
How to design the system that collects metrics and logs from thousands of servers: agents, ingestion, a queue, time-series storage, queries, retention and cost, with the numbers.
28 minRead free - 94
Debugging an incident: a method
A four-step method for a live problem: detect it, narrow it down with the dashboards, stop the damage, and then fix the cause so it does not return.
24 minRead free - 95
Safe releases: canary, blue-green, rollback, feature flags
How to put a new version live so that a bug hurts few users and ends fast: the build and test pipeline, rolling, blue-green and canary releases, rollback, feature flags and A/B tests.
24 minRead free - 96
Testing a system: unit, integration, contract, load, chaos
What unit, integration, contract, load and chaos tests each catch, and how to break a part of a system on purpose in a safe way.
12 minRead free - 97
Containers, Kubernetes and infrastructure as code
Just enough about containers, images, pods, services, deployments and infrastructure as code: what each one is, the problem it solves, and what happens when a container runs out of memory.
12 minRead free - 98
The four usual reasons a cloud bill jumps: servers that are too big, full price for steady load, one user or job that runs wild, and logs that grow without a limit.
12 minRead free
- 88
16Security and privacy6 lessons1 h 24 min
- 99
Who are you: sessions, cookies, JWT
How a server knows who is calling: a session ID in a cookie, or a signed token (JWT). How long each one lasts, and how you cancel a login before it ends.
24 minRead free - 100
OAuth and single sign-on in plain words
How an app gets limited access to your data, or your login, from another service without ever seeing your password, and how one login opens many apps.
12 minRead free - 101
Who may do what: roles and attributes
How a server decides what a logged-in user may do: permissions grouped into roles (RBAC), or rules that read facts about the user and the thing (ABAC).
12 minRead free - 102
How HTTPS keeps a connection private, what a certificate is, how data is protected while it moves and while it is stored, and how keys and passwords are kept safe.
12 minRead free - 103
Common attacks and fixes (OWASP)
Six attacks that fit design questions, each with one fix: SQL injection, broken access control, cross-site scripting, cross-site request forgery, login guessing and server-side request forgery.
12 minRead free - 104
Privacy and compliance: GDPR, India's DPDP Act
What two privacy laws, the European GDPR and India's DPDP Act, ask of a system: a purpose, consent, only the data you need, deletion on time, safe storage and a fast report when data leaks.
12 minRead free
- 99
17Low-level design and machine coding9 lessons3 h 15 min
- 105
How a machine-coding round works
What happens in a machine-coding round, how the time is spent, what the interviewer scores, and what to build first.
12 minRead free - 106
The five SOLID design principles, each shown on a small piece of Python code that you can run: one reason to change, adding without editing, safe substitution, small interfaces, and passing in what a class needs.
20 minRead free - 107
Three patterns that machine-coding rounds reward, each on small Python code: swap a rule (Strategy), tell everyone who asked (Observer), and change behaviour with the status (State).
20 minRead free - 108
Factory, Builder and the Singleton trap
Three creation patterns on small Python code, and the cases where each one is the wrong choice, especially the Singleton, which hides shared state and makes tests fail.
12 minRead free - 109
From requirements to classes, with just enough UML
How to turn a problem statement into classes: find the nouns and verbs, give each rule an owner, draw a class diagram and a sequence diagram in five minutes, and handle a changed requirement with a small edit.
23 minRead free - 110
How to keep shared data correct when many requests run at the same moment: why a counter loses updates, locks, a check followed by a change, atomic steps, deadlock and lock order, a safe cache, and why a lock in code does not protect many servers.
24 minRead free - 111
A parking lot from the problem statement to working Python code: find the classes, put the rules that can change in their own small classes, then add monthly passes with a small change.
28 minRead free - 112
Case study: LLD elevator and vending machine
Two state machines written as working Python code: a lift (one class for each mode, then a fire alarm as a new class) and a vending machine (a table of legal moves, then a stopped state as three new rows).
28 minRead free - 113
A bill-sharing app from the problem statement to working Python code: debts as a graph, whole-rupee splits with a leftover rule, one place that joins opposite debts, settling up, and fewer payments worked out from each person's total.
28 minRead free
- 105
18Interview craft and capstone4 lessons1 h 12 min
- 114
The second half of the round: twists and deep divesFast track
How to handle a sudden change in the problem, how to choose two deep dives, and how to spend the last 18 minutes of a 45-minute round.
24 minRead free - 115
What SDE-1, SDE-2 and SDE-3 answers look like
The same interview question answered at three levels, side by side, so you can see what an SDE-1, an SDE-2 and an SDE-3 answer each contain.
12 minRead free - 116
How to practise: plans and mock interviews
A weekly practice plan with real minutes, how to run a mock interview under the clock, and a short self-review that turns each mistake into a rule.
12 minRead free - 117
Capstone: design and defend a system end to end
One full design round for a food-ordering app: the six steps, then three changes from the interviewer, each defended with one table of load against limit.
24 minRead free
- 114
19AI systems8 lessons2 h 49 min
- 118
How an LLM looks to a system designer: tokens, speed, cost, context limit
What a token is, why you pay for input and output tokens at different prices, why output length decides most of the wait, what the context window limits, and how to work out the cost of an AI feature for 1,000 users.
23 minRead free - 119
Serving an AI feature: streaming, timeouts, fallbacks and limits
How to show an AI answer fast (streaming), which three time limits to set, what to do when the model service fails (a second model, then an honest error), and how to live inside the provider's limits with a waiting line.
24 minRead free - 120
RAG: letting the model read your documents (embeddings, vector search, chunking, freshness)
How an app lets a model answer from your own documents: embeddings, finding the nearest chunks, the HNSW idea, chunk size and overlap, metadata filters, re-indexing, and when keyword search or the whole text in the prompt is enough.
22 minRead free - 121
Caching for AI: prompt cache and meaning cache
Two ways to pay less for AI calls: the provider's prompt cache for the unchanging start of a prompt, and your own meaning cache that reuses an old answer for a similar question, with the rules that keep both safe.
12 minRead free - 122
Is the AI answer good and safe? Evals, prompt injection and output checks
How to test an AI feature with a fixed set of cases scored by code, a second model and people, what prompt injection is, and four defences written in code that still work when the model is fooled.
24 minRead free - 123
Keeping the AI bill under control: routing, budgets and per-user limits
Five ways to keep an AI bill small and safe: send easy work to a small model, cap output length, batch work that can wait, give each user a daily budget with a token bucket, and alert on spend.
12 minRead free - 124
AI agents and tools: loops, safety and idempotent tools
What an AI agent is (a model that calls tools in a loop), when a fixed workflow is better, and the controls that keep an agent safe: limits on steps, time and money, least privilege, approval, idempotent tools, a log of each step, and care with tool results.
24 minRead free - 125
Case study: AI interview coach (Tradeoff itself)
A real AI feature, taken apart: the server keeps the rules and the model only proposes, the model's JSON is checked, every quote in a report is checked, the fixed prompt start is cached, left sessions are finished lazily, and the cost and fair-use limits are worked out.
28 minRead free
- 118
The AI tutor
A tutor beside every lesson
Ask in your own words, any time. The tutor has read the lesson you are on. Reading the lessons is free for everyone; the tutor needs a free account. It will not write your interview answer for you.
It stays inside the lesson
It answers from the lesson first. When your question is outside the lesson, it says so in plain words.
It teaches, it does not hand over answers
Ask for “the answer” and you get a hint first. It usually ends with one short question, to check that you understood.
It uses your kind of English
Short sentences and simple words. Write in Hinglish if you like. Technical words stay in English.
- Free
- 20 questions a day
- 5-Mock Pack
- 30 a day
- Pro
- 50 a day
Practice what you read
Read it. Then try it.
Many lessons end by pointing at something you can try for free. The idea sticks when you use it.
Simulator
Build it. Break it under load.
23 lessons point to a free simulator level. Read about a cache, then build one and watch the numbers move. No account needed.
Drill
Seven minutes. One real situation.
41 lessons point to a Drill or an incident. Today’s Drill is open to read with no account.
Cost lab
Read the cloud bill.
Build a monthly bill for real-looking workloads and hit the budget. You learn the cost levers interviewers ask about. Free.
Start reading
Read a lesson free, right now
No account needed. This is the real lesson text, the same as inside the course. All lessons are free to read; the AI tutor is what you sign up for.
- 01What is system design?What a system design interview really judges: not one right answer, but good choices that fit the needs, with their costs said out loud.20 min read · Core · Starts from zero
- 02How a design round runs: six steps in 45 minutesThe six steps of a design round, a clock for 45 minutes, one small design from start to end, and what each level should do.23 min read · Core
- 03Requirements: what to ask firstHow to turn a short, open question into a list of needs with numbers, and what reliability, scalability and maintainability mean in plain words.22 min read · Core
- 04How good is good enough: uptime and speedWhat 99.9 percent means in hours of downtime, what p50, p95 and p99 mean for speed, and why an average hides slow users.22 min read · Core
Questions
Before you start
Do I need to know anything first?
No. Start at lesson 1. It only asks “what is system design?”. A lesson never uses an idea from a later lesson, so you can read in order and not get lost.
How long does it take?
Every lesson shows its reading time. All 125 lessons add up to about 44 hours of reading. If you build web services at work and have about a week, take the fast track: 34 lessons.
Is it free?
Yes. Every lesson is free to read, with no account and no credit card. A free account adds the AI tutor, the quizzes, your notes and your progress. The tutor has a daily limit: 20 questions a day on the free plan, 30 with the 5-Mock Pack and 50 with the Sprint or the Year pass. See the pricing page for the rest.
Will the English be hard?
No. The course is written for engineers who read English as a second language: short sentences, common words, and every technical word explained. You can also ask the tutor in Hinglish. Technical words stay in English.
Is it a video course?
No. It is text you read at your own speed, with a question to guess before each answer, a quiz after, and an AI tutor beside you.
Start at lesson one
Every lesson is free to read. Sign up free when you want the AI tutor beside you.