Vertical vs horizontal scaling, statelessness, and why reads and writes scale differently.

Quick capacity math: QPS, storage, and bandwidth — expected in every design interview.

What you actually give up in a partition, and the spectrum from strong to eventual consistency.

A repeatable structure: requirements → estimation → high-level design → deep dive → wrap-up.

Global traffic distribution and serving content close to users.

Distributing traffic: algorithms, health checks, and L4 vs L7.

Matching database families to access patterns — the most common design decision.

Copies of data for availability and read scaling — and the lag that comes with it.

Where caches live (client → CDN → app → DB) and the core patterns.

Invalidation, stampedes, and hot keys — where caching bites back.

Async communication patterns and their delivery guarantees.

The distributed log: partitions, consumer groups, and stream retention.

Why distributed systems are hard: partial failure, unreliable networks, and clocks.

Agreement among unreliable nodes: quorums, Raft, and leader election.

The honest trade-offs, migration paths, and the modular monolith middle ground.

Designing with functions and edge compute — cost, cold starts, and state.

The canonical warm-up: ID generation, redirects, and read-heavy caching.

Algorithms, distributed counters, and where the limiter sits.

LSM trees vs B-trees: why some databases write fast and others read fast.

Windowing, watermarks, and exactly-once in Flink-style systems.

The two families of concurrent-editing algorithms and their trade-offs.

Inverted indexes, analysis, and ranking — designing search itself.

Tokens are the scaling unit: batching, KV caches, and GPU capacity math.

Production retrieval: pipelines, reindexing, and multi-tenant isolation.

Active-passive to active-active: data residency, conflicts, and failover drills.

Blast-radius isolation: cells, routing, and shuffle sharding.