System Design
System Design Examples: 12 Real Systems and the One Idea Each Teaches (2026)
System design examples from GTA 6, Netflix, WhatsApp, Uber, Discord and more: the hard constraint, the core design and the trade-off in each, with sources.

Practise system design on a whiteboard the AI reads
The best system design examples are real systems with one hard constraint you can state in a sentence. Study each in four steps: requirements, the constraint, the core design, the trade-off. Below are 12 examples, from GTA 6 to payments, each reduced to the single idea you can reuse in an interview.
Checked November 2026. Every number below links to the engineering post, press release or documentation it came from, and the year of each is stated.
Most pages with this title are lists of interview prompts with a diagram each. They tell you what to draw, which is the part you will forget. This page does the opposite. It picks the number that forced the design, because that number is what an interviewer is really asking about when they say "design WhatsApp."
What are system design examples good for?
A system design example is a worked answer to "how would you build X at this scale." It is useful for three things, and only three.
It teaches you a pattern, such as fan-out, sharding or idempotency, in a setting where the pattern cannot be avoided. It gives you a vocabulary of numbers: what a connection, a message or a cache hit costs. And it gives you a template for the conversation, because every good example moves through the same four steps.
- Requirements. What must the system do, and how will you know it is working?
- The constraint. Which number makes the naive design fail? A million connections, a 33 millisecond frame, a retry that charges twice.
- The core design. The smallest set of components that survives that constraint.
- The trade-off. What you gave up. Every design gives something up, and naming it is most of the score.
If an example you are reading skips step 2, it is a diagram and not an example. Use it for vocabulary and look elsewhere for the reasoning.
System design examples at a glance (checked November 2026)
| System | The hard constraint | Core idea it teaches | Thita lesson |
|---|---|---|---|
| GTA 6 | A fixed frame budget (33.3 ms at 30 fps), and a world too big for memory | Stream by prediction, simulate by distance | GTA 6 engine |
| Netflix | Video bytes are huge and viewers are everywhere | Move the content to the edge before it is asked for | Netflix video delivery |
| Millions of idle, always-on connections per server | One lightweight process per connection | Design WhatsApp | |
| Uber | Supply and demand change by the second and by street | Divide the map into cells and match inside them | Uber real-time matching |
| Discord | Trillions of messages, with a few very hot channels | Partition by channel and time, coalesce duplicate reads | Discord architecture |
| YouTube | One upload becomes many renditions | Split the file, encode the pieces in parallel | Design YouTube |
| Ticketmaster | Far more buyers than seats, all at one second | Queue the crowd, hold seats with a timeout | Design Ticketmaster |
| Twitter / X feed | Reads vastly outnumber writes | Fan-out on write, with a read-time exception | Design a Twitter feed |
| URL shortener | Short codes must be unique, and reads dominate | Generate IDs without collision, cache the read path | Design a URL shortener |
| Rate limiter | One client must not starve everyone else | Token bucket, with shared counters | Design a rate limiter |
| Google Docs | Two people edit the same sentence at once | Transform concurrent edits so all copies converge | Design Google Docs |
| Payment system | A network failure can hide whether money moved | Idempotency keys make retries safe | Design a payment system |
The twelve fall into four families. If you learn the families, a new prompt you have never seen usually lands in one of them.

GTA 6 system design: stream the world, hold a 33 ms frame
A game world is a system with a hard real-time deadline, which makes it the cleanest example of a budget. GTA 6 targets 30 fps on PS5 and Xbox Series X|S (the sourcing is in our post on why GTA 6 runs at 30 fps), and any engine has to finish everything it does inside one frame. At 30 frames per second that is 1000 / 30, or 33.3 milliseconds. At 60 it is 16.7. Streaming, physics, animation, audio, AI and rendering share that slice, so giving one subsystem more means taking from another.
A world this size is too big to keep in memory, so open-world engines typically stream it: load ahead of the camera, keep what is near, and evict what is behind, which is demand paging with a player at the wheel. Crowds usually work the same way. Pedestrians nobody can see are stored cheaply and simulated coarsely, and only the ones near you get full behaviour. Engineers call this simulation level of detail.
Rockstar publishes little about its engine, so the pattern above is the general technique and not a claim about its internals. Our own breakdown separates what is reported from what is inferred. The full subsystem map is in our post on the GTA 6 engine and its system design. The spokes cover why the file is so large and how streaming works, how the NPC and wanted system is built and how GTA Online's servers handle multiplayer.
The trade-off: every fixed budget forces a choice between fidelity and smoothness. A bigger crowd costs frame time.
What it teaches: when time is the constraint, you design a budget first and fit the features inside it.
Netflix system design: put the bytes near the viewer
Netflix has two systems. The cloud runs sign-in, the catalog and recommendations. A separate network of cache servers, called Open Connect, delivers the video. The second is the interesting one, because video is the part that costs bandwidth.
Open Connect appliances (OCAs) are servers full of video files. Per Netflix's Open Connect pages, the same kind of appliance runs in Netflix's 60+ data centers and inside the networks of internet service providers, with embedded appliances provided at no charge to qualifying ISPs. Netflix says it works with over a thousand ISPs. Content is pre-filled before an appliance ships, and nightly fills keep it current, so the video is already there when someone presses play. The ISP steers traffic to the appliance over BGP. If an embedded appliance is down, traffic is re-routed and served from Netflix IX appliances.

The design is a CDN pushed to its logical end. The cloud's job is mostly to decide which cache should serve a viewer, so the heavy bytes travel only a short hop from an appliance close to the viewer.
The trade-off: you pay for hardware in other people's buildings, and you must predict what will be watched. A title that is not on the local appliance is slower and costs more to fetch.
What it teaches: separate the control plane from the data plane, and move the heavy data close to the reader before they ask.
Study the full design in the Netflix video delivery lesson.
WhatsApp system design: one connection per phone
A chat app keeps a connection open to every phone that is online, even though most of them say nothing for minutes. The constraint is how many idle connections one server can hold.
WhatsApp's 2012 engineering post, 1 million is so 2011, reports a single server holding over 2 million TCP connections. The count was 2,277,845 open sockets, on a 24-core Intel Xeon X5675 box with about 96 GiB of memory, running FreeBSD 8.2 and Erlang R14B03. It still had 41.9% CPU idle. That is a 2012 figure from one machine, so read it as a demonstration of the technique and not as today's capacity.
The reason it works is Erlang's model. Each connection is a lightweight process with its own small heap, scheduled by the runtime and not by the operating system, so an idle one costs very little. The operating system needed tuning too. WhatsApp raised the socket and file limits in the kernel to roughly 2.4 and 3 million.
A full chat design adds the parts every interviewer asks about: a message queue for offline recipients, delivery receipts, group fan-out and presence.
The trade-off: a persistent connection makes delivery instant, but a server holding a million connections is a big blast radius when it restarts. Reconnect storms are the failure to plan for.
What it teaches: when the work is waiting, pick the runtime whose idle cost is lowest.
Work through the design in the WhatsApp chat case study.
Uber system design: match riders to drivers by map cell
Uber's constraint is geographic and fast-moving. Drivers move, riders appear, and supply and demand differ from one street to the next. You cannot ask "who is nearest" by scanning every driver in a city.
A common answer is to cut the map into cells and index by cell. Uber built and open-sourced H3 for this, described in its 2018 post H3: Uber's Hexagonal Hierarchical Spatial Index. H3 supports sixteen resolutions, and each finer one has cells with one seventh the area of the coarser one. Hexagons have only one distance between a cell's center and its neighbors, which a square grid does not (a square has two kinds of neighbor). Uber uses H3 to analyze and optimize its marketplaces, and calculates surge pricing "by measuring supply and demand in hexagons in each city."
In a typical design, a match request looks up the rider's cell, searches that cell and its neighbors for drivers, and ranks them. The interesting engineering is in what happens at cell edges and in dense cells.
The trade-off: a coarse grid makes lookups cheap but matches poorly. A fine grid matches well but needs more cells to search. Resolution is a tunable dial, and surge pricing needs a different resolution from dispatch.
What it teaches: turn a continuous space into a key you can shard and look up.
Two Thita lessons cover this ground, the Uber real-time matching architecture and the design-Uber case study.
Discord system design: how it stores trillions of messages
Discord's constraint is storage with uneven load. A few channels are enormous, and a hot channel can slow the machine that holds it.
Discord's March 2023 post, How Discord Stores Trillions of Messages, tells the story with numbers. The message store ran on Cassandra: 12 nodes in 2017, and 177 nodes at the start of 2022. Hot partitions were the problem. Because reads and writes used quorum consistency, one busy channel and time bucket could slow a node, and the slowdown spread to other queries. In May 2022 Discord moved to ScyllaDB, ending with 72 nodes of 9 TB each. The post reports p99 latency for fetching historical messages falling from 40 to 125 ms down to 15 ms, and for inserts from 5 to 70 ms down to a steady 5 ms.
The database was only half of it. Discord put Rust data services between its API and the database. If many users request the same row at the same moment, "we'll only query the database once." Requests are routed by consistent hashing on the channel ID, so identical reads land on the same service instance and can be coalesced.
The trade-off: coalescing and consistent routing add a layer that must be run and kept healthy. You are buying protection from hot rows with more moving parts.
What it teaches: a partition key decides who gets hurt by a hot spot, and a coalescing layer is cheaper than a bigger database.
Study the case in the Discord architecture lesson.
YouTube system design: transcode once, serve many times
One uploaded file becomes many playable files: different resolutions, codecs and bitrates, so a phone on a weak connection and a TV on fiber each get something that plays. The constraint is that encoding is slow and the file is large.
YouTube has not published its pipeline in detail, so this section draws on two companies that have. Netflix's talk on its video encoding describes splitting the source into chunks of about 30 seconds to a couple of minutes, encoding each on separate servers "in a massively parallel way," then stitching the results (InfoQ). It cites a single 30-minute episode producing about 250,000 work items. Meta's engineering team says it receives over 1 billion video uploads a day, and that every upload yields a set of encodings for adaptive streaming that are all created from the same source (Meta Engineering).
The shape of a typical answer: a resumable chunked upload goes to object storage, an event triggers a job graph, workers encode segments in parallel, a packaging step produces the streaming manifests, and the results go to a CDN.
The trade-off: smaller chunks finish sooner but multiply scheduling overhead and the number of boundaries to stitch. A queue protects the workers when uploads arrive in bursts.
What it teaches: split a big job into independent pieces, and let a queue absorb the bursts.
Practice it with the YouTube design case study.
Ticketmaster system design: queue the crowd, protect the seat
Ticketmaster's constraint is demand that exceeds supply by orders of magnitude, arriving in the same second. For the 2022 Eras Tour presale, Ticketmaster's own statement reports 3.5 billion total system requests, four times its previous peak. It says over 3.5 million people pre-registered, about 1.5 million were invited to buy, and over 2 million tickets sold on the day, the most for any artist in a single day. It blamed bots and fans without codes for the surge. Fans and lawmakers disputed that account, so read the numbers as the company's version.
Whatever the cause, the design lessons are the same, and this is what a typical ticketing design looks like, not a description of Ticketmaster's internals. A virtual waiting room admits buyers at a rate the checkout can handle, so the database never sees the full crowd. A seat is held for a short time while the buyer pays, and the hold is atomic, so two people never get the same seat. Verified fan-style registration filters bots before the sale starts.
The trade-off: fairness against throughput. A strict queue is fair but slow, and a free-for-all is fast but rewards bots.
What it teaches: put admission control in front of the scarce resource, and make the hold on that resource atomic with an expiry.
The Ticketmaster case study goes through the seat-hold logic.
Twitter (X) feed system design: fan-out on write vs read
A home timeline is a list of recent posts by the accounts you follow. There are two ways to build it, and the choice is the whole example.
Fan-out on write pushes each new post into every follower's timeline when it is written. Reads become a cheap lookup. Fan-out on read stores each post once and, when someone opens the app, fetches recent posts from everyone they follow and merges them. Writes are cheap and reads are expensive.

Twitter chose write for most accounts. In a summary of Raffi Krikorian's 2012 QCon talk, High Scalability reports about 300,000 requests a second reading timelines against 6,000 a second writing, with tweets pushed into a Redis cluster and each home timeline holding up to 800 entries. Because pushing costs one write per follower, the article's author adds the exception: "For people like Taylor Swift don't bother with fanout anymore, instead merge in her timeline at read time." These are 2012-era numbers.
The trade-off: a read-heavy system favors write-time work, but accounts with huge audiences make the write too expensive. The hybrid is the standard answer.
What it teaches: put the work on the side of the system that runs less often.
The Twitter feed case study covers the hybrid and the ranking layer.
URL shortener system design: short IDs and a cached read path
The URL shortener is the classic first example because its constraint is small enough to compute. If a short code uses seven characters from a 62-symbol alphabet (a-z, A-Z, 0-9), you have 62^7, or 3,521,614,606,208 possible codes. That is about 3.5 trillion, enough that you will not run out, and short enough to type.
The harder question is how to generate codes without collisions across many servers. Common answers are a counter that hands out ranges of numbers to each server and is then encoded in base 62, or a random code checked against the store. A counter avoids collisions but makes codes guessable. Random codes need a uniqueness check.
Reads dwarf writes, so the redirect path is cached. A permanent redirect lets browsers cache the mapping and skip your server, while a temporary one keeps every click visible for analytics. That choice is a product decision disguised as an HTTP detail.
The trade-off: guessable and compact against unguessable and checked. Whether links can be enumerated is a privacy question as much as a technical one.
What it teaches: do the arithmetic on the key space before you pick the scheme, and design the read path before the write path.
There are two versions on Thita, the URL shortener case study and a massive-scale follow-up.
Rate limiter system design: the token bucket
A rate limiter protects a service from one client using all of it. Stripe's engineering post, Scaling your API with rate limiters, is the best public account because it shows layers, not one algorithm.
Stripe describes four. A request rate limiter restricts each user to a number of requests per second, with a short burst allowance for spikes such as flash sales. A concurrent requests limiter caps how many requests a user can have in flight at once, which protects expensive endpoints. A fleet usage load shedder reserves part of the fleet for critical requests, so that with a 20% reservation, non-critical traffic above the other 80% is rejected with a 503. A worker utilization load shedder is the last line of defense during an incident and drops lower-priority traffic first.
The request limiter uses the token bucket algorithm. A bucket holds tokens, each request removes one, tokens refill at a steady rate, and an empty bucket means rejection. Stripe implements its limiters with Redis. A shared store like that is what lets every API server see the same bucket.
The trade-off: a shared counter is accurate but adds a network hop and a dependency to every request. Local counters are fast but allow each server its own quota.
What it teaches: limit more than one thing, because rate, concurrency and priority are separate failure modes.
Try the rate limiter case study.
Google Docs system design: merging edits in real time
Two people type in the same document at once, each on a copy that is a moment out of date. The constraint is that every copy must end up identical, with nobody's work lost and nobody waiting on a lock.
Google's 2010 series of posts on the technology behind Docs, of which What's different about the new Google Docs: Conflict resolution is the second, explains operational transformation (OT). Each editor sends changes to the server, which relays them to the others, and each editor transforms incoming changes so they make sense against its own version. That post gives a concrete case: a bold style over characters 10 to 20, transformed against the insertion of three characters at position 15, becomes a bold style over 10 to 23. Edits that do not conflict, such as italic and a text color, pass through unchanged.
OT is not the only answer. Figma's engineering post on how its multiplayer technology works says OTs "are very complicated and hard to implement correctly," and that Figma isn't using true CRDTs either. It uses a central server to order events and keeps the last value per property.
The trade-off: OT typically relies on a central server and subtle correctness proofs. CRDTs work without a central server but carry more metadata. Per-property last-writer-wins is simple, but concurrent edits to the same property keep only one.
What it teaches: convergence is the requirement, and the data model decides how hard it is.
The Google Docs case study walks through the sync protocol.
Payment system design: idempotency so a retry never charges twice
A payment request can fail in the worst possible place: after the money moved and before the client heard about it. The client cannot tell a lost request from a lost response. The constraint is making a retry safe.
The answer is the idempotency key. Per Stripe's idempotent requests documentation, the client generates a unique key, up to 255 characters, and sends it in the Idempotency-Key header. For API v1, Stripe saves the status code and body of the first request made with that key, and retries return the saved response. It compares incoming parameters against the original and returns an error if they differ. Keys may be pruned once they are at least 24 hours old. Keys are for POST requests, because GET and DELETE are idempotent by definition.

The client side matters too. Stripe's engineering post on idempotency tells clients to keep retrying with the same key, waiting proportionally to 2^n after n failures, plus random jitter so clients do not retry in lockstep.
The trade-off: you must store the key and the result for the retry window, and decide what happens when a second request with the same key arrives while the first is still running.
What it teaches: any operation that can be retried needs an identity that survives the retry.
Practice with the payment system case study, and read the Stripe payment infrastructure lesson for how the pieces fit.
How to use these system design examples to prepare
Do not read all twelve in a weekend. Read one, close it, and redraw it from memory with the constraint written at the top. If you cannot name the constraint, you memorized a diagram.
A sensible order is the URL shortener, the rate limiter and the Twitter feed first, because they use the fewest ideas. Then WhatsApp, Netflix and payments. Save Uber, Discord, Ticketmaster and Google Docs for when the basics feel easy. Stock exchanges and leaderboards are the usual next step, and the stock exchange case study is where to go after these twelve.
Where these examples sit in a full plan is covered in our system design roadmap. If you are choosing what to study with, our ranking of the best system design courses compares price and depth, and a good system design course should include worked examples like these plus a way to practice them aloud. Thita's own system design path and system design sheet cover these case studies and more, and the system design mock interview lets you rehearse the conversation, which no reading replaces.
Frequently Asked Questions
What are some good system design examples for beginners?
Start with the URL shortener, the rate limiter and a Twitter-style feed. Each has one clear constraint and a small number of components. After those, try a chat system like WhatsApp and a video system like Netflix, which add persistent connections and a CDN.
How do I study a system design case study?
Read it in four steps: requirements, the constraint, the core design, the trade-off. Then close it and redraw the design from memory, saying aloud which number forced each choice. If you cannot state the constraint, reread it.
Which system design examples are asked most in interviews?
URL shortener, a news feed, a chat app, a video streaming service, a ride-hailing app, a rate limiter and a ticket booking system come up most often. The examples are interchangeable at the level of ideas, so learning the four families covers most prompts.
Do I need to know how the real company built it?
No. Interviewers grade your reasoning, not whether you match Netflix's internals. The real numbers help because they show scale, but a sound design with named trade-offs beats a recited architecture. Treat engineering blog posts as a source of constraints, not an answer key.
Are numbers from engineering blogs still current?
Often not. The WhatsApp connection count is from 2012, the Twitter timeline figures from 2012, the Uber H3 post from 2018 and the Discord migration from 2022. Use them to understand the shape of the problem and check the date before quoting one as current.
How many system design examples should I practice before an interview?
Eight to ten, chosen across the four families, is enough for most candidates if you can explain each one's constraint and trade-off. Depth on a few beats a skim of thirty. Add company-specific examples in the last week.
Topics
Related on Thita
Your next step
Practise system design on a whiteboard the AI reads
Draw the design while the AI interviewer questions scale, trade-offs and failure modes, then read a scored report. Start with the system design sheet if you want the concepts first.