Interactive system design practice
65 real architectures — from Uber to a key-value store — each built one decision at a time in a diagram you drive. Free, no sign-up.
All system designs
Uber
Build a planet-scale ride-hailing system. Learn how to handle real-time location tracking, matching algorithms, scalability, and payments.
You build Driver App · Backend Server · Database +8
02Start hereCachingURL 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.
You build App Server · URL Store · Key Gen Service +5
03Real-timeBuild 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.
You build Alice · Bob · Relay Server +7
04Fan-outBuild 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.
You build App Server · Tweet Service · Tweet Store +6
05StorageYouTube
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.
You build App Server · Upload Service · Metadata DB +5
06Distributed SystemsRate 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.
You build API Gateway · Rate Limiter · Upstream API +3
07StorageDropbox
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.
You build App Server · Metadata Service · Metadata DB +5
08ConcurrencyTicketmaster
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.
You build API Gateway · Catalog Service · Seat Inventory +5
09Fan-outNotification 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.
You build Notification API · Delivery Workers · Notification Queue +7
10TriesTypeahead (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.
You build Suggest API · Trie Service · Trie Store +6
11Distributed SystemsMessage 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.
You build Broker · Commit Log · Partitioner +4
12Distributed SystemsKey-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.
You build Coordinator · Replica A · Hash Ring +5
13CachingDistributed 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.
You build Cache Client · Database · Cache Node A +5
14Fan-outNews 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.
You build Feed API · Post Store · Social Graph +5
15Distributed SystemsWeb 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.
You build URL Frontier · Fetcher Workers · Parser +6
16Real-timeGoogle 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.
You build Edit Server · Document Model · OT / CRDT +5
17Distributed SystemsJob 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.
You build Scheduler API · Job Store · Due Scanner +5
18StreamingNetflix
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.
You build Playback API · Manifest Service · CDN Edge +5
19StorageBuild 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.
You build API Gateway · Object Store · Metadata DB +6
20StoragePastebin
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.
You build API Server · Metadata DB · Object Store +5
21Distributed SystemsID 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.
You build ID Generator · 64-bit ID · Timestamp +5
22IndexingSearch 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.
You build Query Service · Inverted Index · Query Parser +5
23StreamingAd 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.
You build Ingest API · Event Stream · Stream Processor +5
24SearchAirbnb
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.
You build API Gateway · Search Service · Listings DB +5
25Real-timeSlack
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.
You build Gateway · Channel Service · Message Store +5
26GraphsGoogle 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.
You build Maps API · Tile Service · Tile Store + CDN +6
27Low-latencyStock 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.
You build Order Gateway · Matching Engine · Order Book +6
28ConsistencyPayment 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.
You build Payment API · Payment Worker · PSP / Networks +6
29CachingCDN
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.
You build Origin · Edge PoP · Anycast / GeoDNS +4
30ScalabilityLoad 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.
You build Load Balancer · Server 1 · Server 2 +5
31MicroservicesAPI 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.
You build API Gateway · Users Service · Orders Service +5
32NetworkingDNS
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.
You build Recursive Resolver · Root Servers · TLD Servers +4
33StorageObject 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.
You build S3 API · Storage Node 1 · Storage Node 2 +4
34StorageDistributed 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.
You build Chunkserver 1 · Chunkserver 2 · Chunkserver 3 +4
35StorageTime-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.
You build Ingest · Columnar Shard A · WAL + Memtable +5
36ObservabilityMetrics & 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.
You build Push Gateway · Collector · Time-Series DB +4
37ObservabilityDistributed 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.
You build Trace Context · Agent · Collector +2
38ObservabilityLog 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.
You build Shipper Agent · Buffer · Ingest Pipeline +2
39ScalabilityFeature 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.
You build Flag Store · Dashboard · Flag Delivery +4
40CachingLeaderboard
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.
You build Leaderboard Svc · Sorted Set · Shard A +4
41CachingDistributed 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.
You build Counter Service · Shard A · Shard B +5
42ConsistencyDigital 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.
You build Wallet Service · Transfer Txn · Ledger +4
43Machine LearningFraud 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.
You build Decision Service · Rules Engine · Feature Compute +5
44Real-timeVideo 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.
You build SFU · Signaling · STUN / TURN +2
45StreamingLive 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.
You build Ingest · Transcoder · Packager +2
46Real-timeFood 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.
You build Order Service · Order Store · Dispatcher +2
47GeospatialProximity 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.
You build Proximity Svc · Places Store · Spatial Index +4
48Distributed SystemsDistributed 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.
You build Lock Service · Lock Store · Fencing +2
49Distributed SystemsService 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.
You build Registry · Instance A · Instance B +4
50ConcurrencyFlash 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.
You build Admission · Inventory · Order Service +3
51Real-timeCollaborative Editor
Build a real-time collaborative document editor like Google Docs, Notion or Figma. See why a whole-document lock kills concurrency, how naive position-based edits corrupt a document, how Operational Transformation's central sequencer works and where it bottlenecks, how CRDTs remove that bottleneck with causal, order-independent merges, why presence/cursors live outside the document's durable history, and how offline-first editing and tombstone garbage collection round out the design.
You build Relay · OT Sequencer · Presence +2
52ConsistencyCalendar System
Build a shared calendar like Google Calendar or Outlook. See why storing every recurring occurrence explodes storage, how RRULE-based recurrence is expanded at read time with exceptions layered on top, how free/busy conflict detection stays fast via interval overlap, the timezone/DST trap that can silently shift a recurring meeting by an hour, how invite/RSVP fan-out avoids blocking the organizer, how reminders scale via a time-bucketed trigger index, and how devices sync incrementally.
You build Calendar API · Event Store · Recurrence Expander +4
53ConcurrencyHotel Booking System
Build a hotel/room booking platform like Booking.com or Marriott. See why read-then-decrement inventory oversells rooms, how a multi-night stay needs an all-or-nothing atomic transaction across every date, how reserve-then-confirm with a hold TTL prevents both overselling and cart-abandonment loss, why dynamic pricing is cached rather than computed live, how search is split from the strongly-consistent booking path (CQRS), and how controlled overbooking is a business policy the same atomic system enforces.
You build Booking API · Inventory · Hold Manager +4
54Real-timeDating App
Build a swipe-based dating app like Tinder or Hinge. See why a live full-table nearby scan doesn't scale, how a geospatial index plus a swiped-exclusion set fixes candidate generation, the mutual-match race condition and how a database uniqueness constraint guarantees exactly one match, how ranked feeds are precomputed rather than live, why blocking is deliberately the strictest-consistency path in the whole system, and how bot/fake-profile detection runs quietly, asynchronously, off the hot path.
You build API · User Table Scan · Likes / Matches +4
55Real-timeRide-Matching Engine
Build the matching and dispatch engine at the heart of a ride-hailing platform — the specific subsystem deciding which driver gets which rider, not the trip lifecycle or payments. See why straight-line distance is a bad proxy for real ETA, why greedy one-at-a-time matching is globally suboptimal, how batch matching solves an assignment-optimization problem across a short window, surge pricing as supply/demand balancing, ingesting driver locations at write-heavy scale, and fairness for idle drivers.
You build Dispatch API · Driver Geo Index · ETA / Routing +3
56Distributed SystemsLogging Pipeline
Build the ingestion pipeline that collects, buffers and delivers logs from thousands of services — the write path, not the query/search side. See why synchronous writes to a central log server are dangerous, local agent buffering, bounded backpressure and overflow policy, batching for throughput, where structured parsing should happen, at-least-once delivery with dedup, sampling at high volume, and why a logging storm can take down the very system it was meant to observe.
You build Log Store · Log Agent · Durable Queue +3
57Distributed SystemsEmail System
Build an email system like Gmail or Outlook. See why raw inbound mail can't land straight in a mailbox, retry-with-backoff for unreliable delivery across the open internet, layered spam/authentication filtering, per-user mailbox sharding, thread reconstruction via message headers instead of subject lines, delivery dedup and bounce-loop prevention, and IMAP-style incremental multi-device sync.
You build Inbound MTA · Outbound MTA · Spam / Auth Filter +3
58ConcurrencyOnline Judge
Build a code-execution judge like LeetCode, Codeforces or HackerRank's backend. See why running submitted code inline is a security catastrophe, what real sandboxing has to guarantee beyond just a container, async queue-based execution for contest-scale bursts, verdict determination across hidden test cases, CPU-time (not wall-clock) resource limits for fairness, judge determinism, and fair queueing so one flood of submissions can't starve everyone else.
You build Submission API · Sandbox Workers · Job Queue +3
59FDEWebhook Ingestion at Scale
Build a reliable webhook ingestion pipeline — the backbone of every integration. Learn signature verification and replay protection, acknowledging fast with a durable queue, idempotent processing that turns at-least-once delivery into effectively exactly-once, bounded retries with a dead-letter queue, replay after a fix, and monitoring consumer lag and DLQ depth.
You build Ingest API · Verify · Durable Queue +5
60FDECustomer Data Integration Pipeline
Build the pipeline that ingests a customer’s messy data on almost every deployment. Learn source connectors (API, SFTP, database, change-data-capture), staging, validation and mapping to a canonical schema, quarantining bad rows instead of dropping them, incremental sync by checkpoint, idempotent upsert loads with backfill, and reconciliation that proves the data landed.
You build Ingestion · Connectors · Staging +5
61FDEMulti-Tenant Customer Isolation
Serve many customers from one system without ever leaking data between them. Learn tenant context propagation, the data-isolation spectrum (row-level, schema-per-tenant, database-per-tenant), preventing noisy neighbors with per-tenant quotas, per-tenant encryption keys and config, and audit plus automated cross-tenant tests that make isolation provable.
You build API Gateway · Tenant Resolver · App Tier +5
62FDEAudit Logging & Compliance Trail
Build the audit system that passes a customer’s security review. Learn structured capture of who-did-what-when, an append-only immutable (WORM) store, tamper-evidence with hash chaining, retention and archival for compliance windows, and access-controlled querying that redacts sensitive data and audits the auditors.
You build Application · Immutable Store · Audit Capture +5
63FDEEnterprise Eval Pipeline
Turn “it should be accurate” into a gate that blocks a merge. Learn a stratified frozen golden set, the inter-expert agreement ceiling that sets a defensible target, an LLM judge reported with its calibration, a CI gate asserting per-case regressions rather than an average, drift monitoring that separates distribution shift from score decay, and the one business number the renewal actually turns on.
You build Eval Runner · Golden Set · Human Ceiling +5
64FDEAgent Harness (AI-Supervised Delivery)
The shift from writing feature code to writing the systems that write it. Learn task decomposition into machine-verifiable units, a narrow designed tool surface instead of shell access, per-task sandboxes that make failure cheap, a verification gate the agent cannot reach, a review queue routed by blast radius, repo-grounded context, and the ledger that makes agent work auditable.
You build Agent · Tool Surface · Sandbox +5
65FDEEnterprise SSO & Provisioning
The layer that blocks more enterprise deals than model quality. Learn multi-tenant SAML and OIDC federation, keying users on an immutable subject identifier, SCIM where deactivation arrives as a PATCH rather than a DELETE, group-to-role mapping that survives a reorg, revoking live sessions and API tokens inside the promised window, and the evidence a security reviewer asks for.
You build Auth Service · SAML / OIDC · User Record +4
The fundamentals behind every design
Every system above 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 FundamentalsThe four ideas behind every design — read this first.
- CAP & ConsistencyCP vs AP, PACELC, linearizable → eventual.
- Concurrency & LockingOptimistic vs pessimistic, isolation, MVCC.
- Partitioning & ReplicationSharding, consistent hashing, quorums.
- Consensus & CoordinationRaft/Paxos, 2PC vs saga, idempotency.
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.