Master the systems
that run the world.
Build real architectures step by step — from Uber to a key-value store — through interactive diagrams that grow one concept at a time. Then learn the fundamentals beneath them all.
The fundamentals behind every design
Every system below is a recombination of the same core ideas. Learn them once in the System Design Fundamentals handbook, then spot them in each design.
System Design Fundamentals
The four ideas behind every design — read this first.
01CAP & Consistency
CP vs AP, PACELC, linearizable → eventual.
02Concurrency & Locking
Optimistic vs pessimistic, isolation, MVCC.
03Partitioning & Replication
Sharding, consistent hashing, quorums.
04Consensus & Coordination
Raft/Paxos, 2PC vs saga, idempotency.
Browse all designs
50 designsDesign Uber
Build a planet-scale ride-hailing system. Learn how to handle real-time location tracking, matching algorithms, scalability, and payments.
Design a URL Shortener
Build a URL shortener (think Bitly or TinyURL). Learn how to mint unique short codes with base62, make the read-heavy redirect path sub-millisecond with caching, shard billions of mappings, and track clicks asynchronously.
Design WhatsApp
Build a real-time messaging system. See how persistent WebSockets, a session registry, offline inbox queues, the ✓✓ delivery receipts, group fan-out, media on a CDN, and end-to-end encryption fit together.
Design Twitter
Build Twitter's news feed. Learn the social graph, why fan-out on write beats read-time merging, how a precomputed timeline cache makes feed reads O(1), how ranking surfaces the best tweets, and how a hybrid model solves the celebrity problem.
Design YouTube
Build a planet-scale video platform. See how raw uploads become an adaptive-bitrate ladder through an async transcoding pipeline, how a CDN serves immutable segments from the edge, how tiered blob storage holds exabytes affordably, and how view counts stay async.
Design a Rate Limiter
Build a distributed rate limiter. Learn where to put the check, how to key and tier limits, the token-bucket and sliding-window algorithms, why shared atomic counters in Redis avoid race conditions, and the fail-open vs fail-closed trade-off.
Design Dropbox
Build a file sync engine. See how splitting metadata from bytes, content-addressed block storage with deduplication, delta sync, a push-then-pull notification service, and conflict-safe versioning fit together to keep files consistent across every device.
Design Ticketmaster
Build an event-booking system. Tackle the double-booking problem head-on: seat inventory, short-lived holds with TTLs, exactly-once purchases via ACID transactions, payment sagas with idempotency, and a virtual waiting room that tames the on-sale stampede.
Design a Notification System
Build a multi-channel notification system. See how one API, a message queue and a worker fleet decouple slow third-party delivery, how preferences and quiet hours gate every send, how templates fan out to push, SMS and email, and how delivery tracking, retries, dedup and rate limits keep it reliable.
Design Typeahead (Autocomplete)
Build a search typeahead. See how a prefix trie turns search into an O(L) walk, how a prefix-keyed cache answers the skewed common case in under a millisecond, how precomputed top-k ranking surfaces the best ten, how an offline builder keeps suggestions fresh from query logs, and how to personalize and shard.
Design a Message Queue
Build a distributed message queue like Kafka. See how an append-only commit log, partitions keyed for order, consumer groups with server-side offsets, leader/follower replication, controller-driven leader election, retention and compaction, and exactly-once guarantees fit together.
Design a Key-Value Store
Build a distributed key-value store like DynamoDB. See how consistent hashing places keys, how replication and tunable quorums (R + W > N) trade consistency for availability, how vector clocks resolve conflicts, and how gossip membership, hinted handoff and read repair keep it alive through failure.
Design a Distributed Cache
Build a distributed cache like Redis or Memcached. See how cache-aside shields the database, how consistent hashing shards across nodes, how TTL and LRU/LFU eviction bound memory, how replication and invalidation keep it correct, and how to survive cache stampedes and hot keys.
Design a News Feed
Build a social news feed. See how the social graph, pull vs push fan-out, a precomputed feed cache, relevance ranking, the hybrid model that tames the celebrity problem, blending multiple content sources, and cursor pagination fit together.
Design a Web Crawler
Build a distributed web crawler. See how a URL frontier drives the fetch–parse–enqueue loop, how a bloom-filter seen-set stops infinite re-crawling, how politeness and robots.txt keep you a good citizen, how DNS caching and content dedup remove bottlenecks, and how to shard the frontier by host and dodge traps.
Design Google Docs
Build a real-time collaborative editor. See how edits become tiny operations, how OT and CRDTs resolve concurrent edits so every copy converges, how ops broadcast over WebSockets, how an op log plus snapshots give history and recovery, and how presence, offline sync and per-document sharding fit together.
Design a Job Scheduler
Build a distributed job scheduler (cron at scale). See how a durable job store indexed by run time, a due scanner, a ready queue feeding a worker pool, idempotent at-least-once execution, leader election to avoid double-fires, retries with backoff and a DLQ, and time-wheel sharding fit together.
Design Netflix
Build a planet-scale video streaming service. See how the play path splits authorization from byte delivery, how origin storage and CDN edges serve immutable segments, how an adaptive-bitrate ladder adapts to any connection, how a parallel transcoding pipeline builds it, and how Open Connect, recommendations and QoE events fit together.
Design Instagram
Build a photo-sharing app. See how splitting media from metadata, a CDN for immutable images, async image processing, a precomputed feed cache, asynchronous like/view counters, TTL-based ephemeral stories, and sharding fit together to serve billions of photos.
Design Pastebin
Build a text-paste service. See how base62 key generation, separating metadata from blob storage, a cache and CDN for the read-heavy immutable path, TTL expiration, privacy flags and size limits, and async analytics fit together.
Design an ID Generator
Build a distributed unique ID generator like Twitter Snowflake. See why auto-increment and UUIDs fall short, how a 64-bit ID packs a timestamp, machine id and sequence to stay collision-free and time-sortable without per-ID coordination, how machine ids are assigned, and how clock skew is handled.
Design a Search Engine
Build a web search engine. See how an inverted index turns search into list lookups, how query parsing mirrors indexing, how an offline indexer builds postings, how BM25 and PageRank rank results, and how document-sharded scatter-gather, result caching and a fresh index scale it to billions of pages.
Design an Ad Click Aggregator
Build a real-time ad click aggregator. See how a thin ingest API and event stream absorb millions of clicks a second, how a stream processor aggregates into time windows, how dedup keys give exactly-once counts, how a raw event lake and batch recompute reconcile the numbers, and how fraud filtering and watermarks handle the sharp edges.
Design Airbnb
Build a lodging marketplace. See how listings and geo search with filters, per-listing availability calendars, atomic booking that never double-books, payment hold-and-capture with idempotency, event-driven reviews and reindexing, and read replicas fit together.
Design Slack
Build a team chat app. See how channel messaging and per-channel history, real-time delivery over WebSockets with a session registry, cross-server fan-out via pub/sub, ephemeral presence and typing, message search, unread counts and notifications, and channel sharding fit together.
Design Google Maps
Build a mapping and navigation service. See how pre-rendered map tiles on a CDN, a weighted road graph, A* shortest-path routing, contraction hierarchies for instant long routes, crowdsourced traffic for live ETAs, geocoding, and regional graph partitioning fit together.
Design a Stock Exchange
Build a stock exchange matching engine. See how an in-memory order book with price-time priority matches orders, how pre-trade risk checks guard the core, how a single sequencer and single-threaded engine give deterministic low-latency matching, and how market-data feeds, journaling/replay, clearing and symbol partitioning fit together.
Design a Payment System
Build a payment system like Stripe. See how a payment is modeled as a state machine of authorize and capture, how idempotency keys prevent double-charges, how a double-entry ledger keeps every cent auditable, how tokenization shrinks PCI scope, and how async webhooks, reconciliation and a durable retryable worker handle slow banks and failure.
Design a CDN
Build a Content Delivery Network like Cloudflare or Akamai. See why distance is the enemy, how edge PoPs cache content near users, how anycast/GeoDNS routes to the nearest edge, how Cache-Control TTLs and tiered shield caches protect the origin, how versioned URLs and purge solve invalidation, and how stale-while-revalidate keeps it fast and up.
Design a Load Balancer
Build a load balancer like NGINX or HAProxy. Learn why you scale out instead of up, how one entry point fronts a pool of stateless servers, how balancing algorithms (round-robin, least-connections, weighted, hashing) pick a server, how health checks evict dead boxes, L4 vs L7 routing, and how to make the balancer itself redundant.
Design an API Gateway
Build an API gateway like Kong or Amazon API Gateway. See how one front door decouples clients from your microservices, how it routes by path, offloads authentication and rate limiting to the edge, aggregates responses (BFF) and caches hot GETs, stays stateless and pooled, and isolates a failing service with timeouts and circuit breakers.
Design DNS
Build the Domain Name System. See why one central name→IP table can't work, how a delegated hierarchy of root, TLD and authoritative servers splits the namespace, how a recursive resolver walks it, how caching with TTLs makes lookups instant, how replication and anycast make it DDoS-proof, and how GeoDNS, DNSSEC and propagation work.
Design Object Storage
Build an object store like Amazon S3. See why one disk caps capacity, durability and availability, how a flat bucket/key namespace scales to trillions of immutable objects, how a metadata service maps keys to chunk locations, how replication and erasure coding deliver eleven-nines durability, how read-after-write consistency is anchored in metadata, and how multipart uploads, tiering and background repair work.
Design a Distributed File System
Build a distributed file system like GFS or HDFS. See why one file server caps capacity and throughput, how huge files split into large chunks across chunkservers, how a single master serves only metadata while clients stream bytes directly, how rack-aware replication survives correlated failures, how a leased primary orders pipelined writes, and how the master is made recoverable.
Design a Time-Series Database
Build a time-series database like InfluxDB or Prometheus TSDB. See why a row-per-point SQL table melts, how series = metric + tags models the data, how columnar storage with delta-of-delta timestamps and XOR values shrinks points to ~1–2 bytes, how an LSM write path with a WAL swallows the firehose, how sharding by series and downsampling work, and why cardinality is the real scaling limit.
Design a Metrics & Monitoring System
Build a monitoring system like Prometheus or Datadog. See why SSH-and-grep can't scale, how counters, gauges and histograms instrument the golden signals, pull vs push collection, storing the sample firehose in a time-series database, splitting alerting into a rule evaluator and an alert manager that dedupes and routes, dashboards, HA collectors and federation, and why you must monitor the monitor.
Design a Distributed Tracing System
Build a distributed tracing system like Jaeger or Honeycomb. See why metrics and logs can't explain one slow cross-service request, how spans sharing a trace id form a waterfall, how trace context propagates in headers across every hop, how spans are emitted fire-and-forget through agents to a collector, why tail-based sampling keeps the errors and slow traces, and how the trace store serves both assembly and search.
Design a Log Search System
Build a log aggregation and search system like the ELK stack or Loki. See why grep-over-SSH can't scale, how structured logs and shipper agents get data off ephemeral hosts, how a Kafka buffer absorbs bursts, how a parse/enrich pipeline feeds an inverted index, how time-based sharding and scatter-gather search billions of lines in milliseconds, and how hot-warm-cold retention bounds cost.
Design a Feature Flag System
Build a feature flag / experimentation platform like LaunchDarkly. See why redeploying to toggle a feature is slow and risky, how a flag store + dashboard lift decisions out of code, how an SDK evaluates flags locally with zero network calls, how consistent-hash bucketing gives sticky percentage rollouts, how local cache + streaming + edge deliver a millisecond kill switch, and how exposure events turn a flag into an A/B experiment.
Design a Leaderboard
Build a real-time leaderboard for millions of players. See why SQL ORDER BY + COUNT rank melts at scale, how a sorted set (Redis ZSET) gives O(log N) update/rank and O(log N + K) top-K, how relative "around me" boards work, why sharding a global ranking is uniquely hard, how time-windowed boards reset cleanly, and how a durable store backs the rebuildable in-memory index.
Design a Distributed Counter
Build a distributed counter for view counts and likes at massive scale. See why a single UPDATE row melts under write contention, how sharding into N sub-counters trades read cost for parallel writes, how batching through a stream cuts write volume, how a cached total makes reads O(1), how HyperLogLog counts uniques in a few KB, and how idempotency keys make increments exactly-once.
Design a Digital Wallet
Build a digital wallet like PayPal or Venmo. See why a mutable balance column is dangerous, how an append-only double-entry ledger makes balance derived and money conserved, how atomic debit+credit transfers survive a mid-transfer crash, how idempotency keys stop double-charges, how per-account locking prevents double-spend, how cross-shard transfers use sagas, and how pending/settled states and reconciliation handle slow bank rails.
Design a Fraud Detection System
Build a real-time fraud detection system like Stripe Radar. See why static rules fail against an adaptive adversary, how real-time features (velocity, device, geo) from a feature store carry the signal, how an ML model blends with rules under an ~80ms budget, how streaming aggregations keep features fresh, how the chargeback/label feedback loop retrains the model, and how allow/deny/step-up decisioning and graph features handle nuance and fraud rings.
Design a Video Conferencing System
Build a video conferencing system like Zoom or Google Meet. See why real-time media needs UDP/WebRTC not TCP, why a peer-to-peer mesh explodes at N², how an SFU lets each peer upload once and forwards streams, how simulcast adapts quality per receiver, how signaling with SDP and ICE/STUN/TURN connects peers across NATs, and how geo-distributed cascaded SFUs scale to huge global calls.
Design a Live Streaming System
Build a live video streaming system like Twitch or YouTube Live. See why it optimizes for cheap CDN fan-out instead of ultra-low latency, how ingest accepts one broadcaster push, how transcoding builds an adaptive bitrate ladder, how HLS/DASH segmenting turns live video into cacheable HTTP files, how a CDN fans them to millions, the latency-vs-scale dial, and how live chat and DVR/VOD fit in.
Design a Food Delivery System
Build a food delivery system like DoorDash or Uber Eats. See why it's a three-sided marketplace plus a real-time logistics engine, how the order lifecycle is a durable state machine, how the dispatch engine optimizes courier assignment (who and when, not nearest-now), how location tracking and geo-indexing work, how ETA is an ML sum of prep + travel + wait, and how geo-sharding and surge balance supply and demand.
Design a Proximity Service
Build a proximity / nearby-search service like Yelp or "find drivers near me". See why SQL distance queries degrade to full scans, the 2D indexing problem, how geohash encodes 2D into a locality-preserving 1D key, how quadtrees and S2 cells adapt to density, the cell-boundary problem, caching hot cells, and how moving objects and geo-sharding are handled.
Design a Distributed Lock
Build a distributed lock (mutual exclusion across machines) like Redis locks, Redlock or etcd/ZooKeeper locks. See why a "locked=true" flag deadlocks and races, how atomic acquire grants to exactly one, how a TTL lease auto-releases a dead holder, how ownership tokens make release safe, why fencing tokens are the real safety mechanism against pauses, and why correctness-critical locks need a consensus quorum.
Design a Service Discovery System
Build a service discovery system like Consul, etcd, Eureka or Kubernetes DNS. See why hardcoded IPs break in a dynamic fleet, how a service registry maps names to live instances, how self-registration and health checks keep it accurate, the client-side vs server-side discovery tradeoff, why the registry needs consensus (CP) or accepts AP staleness, and how caching and watches keep lookups fast and fresh.
Design a Flash Sale System
Build a flash-sale / limited-inventory system for a massive concurrent drop. See why read-then-decrement oversells, how admission control and a virtual waiting room pace the thundering herd, how an atomic inventory decrement guarantees exactly N buyers win, how reserve-then-confirm with a hold TTL and async order processing work, and how to tame the single hot inventory key with fairness and anti-bot defenses.
System design — frequently asked questions
What is system design and why does it matter for interviews?
System design is the practice of architecting large-scale software systems — choosing how data is stored, partitioned, cached, and moved so the system stays fast, available, and consistent under load. It is a core round in senior and staff engineering interviews because it reveals how you reason about trade-offs, not just whether you can code.
How are these system-design guides different from articles?
Each guide is an interactive diagram that grows one concept at a time. Instead of reading a wall of text, you build the system step by step — adding a cache, a queue, or a shard and seeing why each piece is needed — which makes the trade-offs stick far better than a static post.
Are the system-design guides free?
Yes. Every guide is free, self-contained, and runs in your browser with no sign-up. You can work through all of them at your own pace.
Which system design should I start with?
Start with a Beginner guide like the URL Shortener to learn the core pattern of caching, sharding, and read/write paths, then read the System Design Fundamentals handbook for the underlying ideas before moving to Advanced designs like Twitter or a key-value store.
Will these help with FAANG / big-tech interviews?
Yes. The library covers the systems most commonly asked at large tech companies — feeds, messaging, rate limiters, key-value stores, payments and more — and each guide foregrounds the trade-offs (consistency vs availability, fan-out on read vs write) that interviewers probe for.
Pick a system. Start building.
Every guide is interactive and self-contained — no setup, no sign-up. Begin with a simple one, or jump straight to the concepts.