Foundations
How to think about a design before you draw a single boxHow to run the interview: clarify requirements, estimate, find the bottleneck, propose a design, then iterate.
Back of envelope math for QPS, storage, bandwidth and memory, plus the numbers worth memorizing.
CAP theorem, PACELC, ACID vs BASE, and the difference between strong, eventual and causal consistency.
A reference for the costs behind every decision: latency vs consistency, cost vs durability, simplicity vs flexibility.
Networking & Communication
How data moves and how services find and talk to each otherWhat happens between the browser and your load balancer: DNS, TCP, TLS, HTTP versions, and CDN edge delivery.
REST vs gRPC vs GraphQL, request-response vs event-driven, and API details like pagination and idempotency keys.
Polling, SSE and WebSockets, holding a million live connections, and delivery over flaky links.
Message queues vs pub/sub vs event streaming, and the delivery guarantees each one actually gives you.
Load balancing algorithms, L4 vs L7, health checks, service discovery, and the API gateway at the edge.
Data & Storage
Choosing and shaping where the data livesThe real tradeoffs between relational and non-relational stores, and when each one wins.
B-trees vs LSM trees, composite and covering indexes, and the write cost every index carries.
Splitting data across nodes, consistent hashing, hot spots, rebalancing, and unique ID generation.
Leader-follower and multi-leader replication, quorum reads and writes, and how write-ahead logs guarantee durability.
Time series, columnar, graph, blob and geospatial stores, and the workloads that make each one the right call.
Cache-aside, write-through and write-behind, invalidation strategies, and the cache stampede problem.
Data Processing
Turning raw event streams into answersReliability
Patterns for surviving failure instead of pretending it won't happenCircuit breaker, retry with backoff and jitter, bulkhead, timeout, and graceful degradation vs failing hard.
Saga pattern, the outbox pattern for reliable event publishing, two-phase commit, and change data capture.
Idempotency, at-least-once vs exactly-once, optimistic vs pessimistic locking, distributed locks, and logical clocks.
Quorums, leader election, and Raft in depth, the machinery behind everywhere "exactly one" must be true.
Architecture & Scale
Growing a system without it falling overMonolith vs microservices, how to draw boundaries, and when splitting things up is the wrong call.
Horizontal vs vertical scaling, statelessness, the scaling sequence, autoscaling, and rate limiting.
Active-active vs active-passive deployments, disaster recovery, and data residency constraints.
Operations
Running the system in productionWhat each signal is actually for, the four golden signals, and distributed tracing across service boundaries.
Error budgets, the difference between all three terms, the nines, and why you alert on symptoms, not causes.
Authentication vs authorization, encryption in transit and at rest, secrets management, and the perimeter.
Case Studies
Worked designs from requirements to tradeoffsThe classic warm up: key generation, redirect latency, and read heavy caching.
Token bucket, sliding window, and distributed counting across a fleet of gateways.
Prefix suggestions under 100ms: tries with precomputed top-k and an offline aggregation pipeline.
Real time delivery, message ordering, presence, and fan out for group conversations.
Push vs pull fan out, ranking, and handling celebrity accounts with millions of followers.
Upload, transcode and adaptive playback, with the metadata/payload split that carries the design.
Geospatial indexing, real time matching, and dispatch under location heavy write load.
Distributed cron, exactly-once execution, retries, and handling clock drift across workers.