The complete knowledge map

Distributes incoming traffic across a pool of servers for scale and fault tolerance.

Single entry point that handles auth, rate limiting, routing, and protocol translation for downstream services.

A globally distributed cache that serves static and cacheable dynamic content close to the user.

An in-memory key-value store used for caching, pub/sub, rate limiting, distributed locks, and simple queues.

A row-oriented, ACID-compliant relational database — the default for transactional workloads.

The world's most-deployed open-source relational database — clustered PK index, InnoDB MVCC, Vitess for sharding at billions-of-rows scale.

The extensible, standards-compliant relational database — MVCC via xmin/xmax, richest type system in SQL, extensions from PostGIS to pgvector.

Umbrella for document, wide-column, and key-value stores optimized for horizontal scale over strict schema.

A distributed, partitioned, replicated commit log for event streaming, high-throughput ingest, and decoupled services.

Async task queue that decouples producers from consumers and smooths bursts. Each message is processed exactly once (per-message ACK model).

Durable, cheap, flat-namespace storage for blobs — images, videos, backups, logs, and any large binary object.

Inverted-index-based full-text and structured search — the right tool for 'find me records matching this query' when SQL LIKE isn't fast enough.

Continuous computation over event streams — windowed aggregations, joins, ML features, and event-driven derived views.

Enforces per-caller (per-user, per-IP, per-tenant) request budgets to protect downstream systems from abuse and overload.

Runs jobs at a time or interval — the simplest form of eventual asynchronous computation.

Orchestrates long-running, stateful multi-step processes — the right tool when a business flow involves many services and can span days.

Cross-node mutual exclusion — 'only one node can do this at a time' when you can't rely on a single-node lock.

How services find each other in a dynamic fleet — because IPs change, nodes come and go, and hardcoding is a losing game.

Horizontally-scaled database with automatic partitioning and replication — the answer when one node can't hold the data or the traffic.

Reads dominate your workload, and every read hits a slow store (database, disk, network). Latency and load on the primary storage climb until the primary becomes the bottleneck.

Your application logic has to duplicate cache-management code everywhere it reads — check cache, on miss read DB, populate cache, return.

In cache-aside, cache and DB can diverge briefly on writes. You need stronger cache-consistency.

Write throughput is high; every write hitting the DB creates load. But you don't need writes to be durable in the DB immediately.

Cache-aside with writes populating the cache can pollute the cache with never-read data (write-heavy but read-rare content).

You want to broadcast an event to multiple consumers without coupling the producer to the list of consumers.

Tight coupling between services makes evolution painful. When service A directly calls service B, they must deploy together, know each other's contracts, and B's failures propagate to A.

Your write model and read model have very different needs. Optimizing for one hurts the other.

Traditional state-based storage loses history: you know the current balance, but not why it's that value. Auditing, replay, and temporal queries are hard.

You have a business transaction that spans multiple services or databases (place order → charge payment → reserve inventory → send confirmation). Two-phase commit is too slow, too coupling, and often not available across service boundaries.

You need to atomically update your database AND publish an event to Kafka. Two-phase commit isn't available; publishing before the DB commit risks phantom events; publishing after risks lost events on crash.

You want to derive downstream systems (search index, cache, analytics) from your primary database — but polling for changes is expensive and misses deletes.

Your dataset or write throughput has outgrown a single node. A single primary DB or single cache node can't hold the data or handle the QPS.

You need to shard keys across N nodes, but N changes over time (nodes added, removed, or failed). Naive hash-mod-N reshuffles almost everything on every change — cache is wiped, migration cost is huge.

One node can't handle all reads. And if the node dies, you lose everything.

You need HA and scale in multiple regions. Passive standby wastes capacity; leader-follower has one region doing all the writes.

You need HA but don't want the complexity or cost of active-active.

One event or write must be distributed to many consumers or write destinations.

You need to answer a query that requires data from multiple shards/services, and you need the aggregate result.

One misbehaving caller or workload consumes all your resources (threads, connections, memory) and starves everyone else.

A downstream service is unhealthy. Your service keeps calling it, waiting the full timeout on every call, exhausting your thread pool, and cascading the failure back to your callers.

Transient failures (network hiccup, brief overload) succeed on retry. Retrying immediately makes overload worse (retry storm).

Producers publish faster than consumers can process. Queues grow unbounded, memory fills up, and everything crashes.

One bad actor can consume all your capacity. And even good actors need bounds so you can capacity-plan.

Your system is overloaded. Continuing to accept work makes it worse (all requests get slow, none complete on time).

You have a legacy monolith you want to replace, but a big-bang rewrite is too risky.

The system-design interview's most famous first problem. We treat it as a scale-evolution study: four architectures for the same problem, from 10K to 1B RPS.

Store and share text snippets by URL.

Direct-to-storage uploads with pre-signed URLs.

1:1 messaging with delivery guarantees.

Enqueue and run one-shot and recurring tasks.

Deliver push/email/SMS to a targeted user.

Enforce budget on requests per client per window.

Create polls, cast votes, tally results.

Discover, fetch, and store the web in a bounded way.

Photo/video feed, uploads, stories, direct-to-S3 media, hybrid fan-out feed, ML ranking.

Timeline generation with hybrid fan-out — push for regular users, pull for celebrities.

Upload → transcode → CDN → recommendations. HLS delivery, ABR ladder, per-title encoding.

Block-level sync, deduplication, delta upload, conflict resolution.

Collaborative document storage.

Global video streaming — CDN economics, ABR, DRM, chaos engineering, Open Connect.

Uber's real architectural evolution — monolith → SOA → Ringpop → DOMA.

1:1 and group messaging at scale — WebSocket + MQTT, E2E encryption, multi-device sync.

Team messaging with presence, threads, search. Sharded WebSocket, team-affinity routing.

Concurrency control on hot seats. Hybrid Redis+DB holds, virtual queue for drops, anti-scalping.

Restaurant discovery, order, delivery orchestration.

H3 geo-indexing, DISCO batched matching, surge pricing, city-sharded state.

Catalog, cart, checkout, inventory.

Idempotent money movement with a double-entry ledger, provider integration, and reconciliation.

Multi-tenant SaaS notification platform — templates, providers, orchestration, delivery receipts.

Sub-100ms typed suggestions.

Ranked, personalized feed generation.

In-memory KV cluster with replication.

Crawl → index → serve, at web scale.

Cross-region, high-throughput push.

Approximate-consistent counters across regions.

Scale-out cron with exactly-once semantics.

Ingest, index, and search at petabyte scale.

Time-series ingest + query + alert.

Sharded inverted index + query fan-out.

Multi-region ledger with reconciliation.

Real-time bidding + serving in <100ms.

Feature store, model serving, A/B.

Streaming ingest + interactive query.

Distributed log with partitioning + replication.

Sharded, replicated, with configurable consistency.

Cross-region durable object storage.

Global-scale video with adaptive bitrate + recommendations.

Edge-heavy streaming at planetary scale.

Product-first framing — you connect the design to real user impact

Operational rigor — how would you run this on-call?

Depth on distributed systems primitives (consensus, replication, sharding)

Resilience-first thinking — assume failure, design around it

Realistic geo reasoning — H3, quad-trees, geohashing

Azure-service familiarity — you know when to reach for Cosmos DB vs SQL DB vs Cache

Correctness of money movement — idempotency is non-negotiable

Edge-first thinking — assume the answer runs in every PoP