We use cookies for site analytics. Accept to help us understand how the site is used. See our Privacy Policy for details.
Curated walkthroughs for the bounded designs that show up in real interview loops. Each topic covers requirements, capacity estimation, architecture, deep-dives, and the trade-offs interviewers actually probe for.
The canonical bounded system design problem. Read-heavy, hot-key prone, and a great vehicle for hashing, caching, and capacity estimation.
The classic write-vs-read amplification trade-off. Push, pull, or hybrid fanout - and how to handle the celebrity user with 100M followers.
Five algorithms, three sharding strategies, one fail-open vs fail-closed decision. The bounded design that surfaces in every backend interview loop.
Long-lived connections, ordering guarantees, presence, and the difference between 1:1 chat and a 50K-member group.
Consistent hashing, eviction, replication, and what really happens when a single hot key takes down the cluster.
Politeness, deduplication, freshness, and the URL frontier. The classic crawl-the-internet question that surfaces deep distributed systems judgment.
Encoding ladders, adaptive bitrate, CDN economics, and the difference between live and VOD. Petabyte-scale storage meets millisecond-scale playback.
Geo-indexing, real-time matching, ETA prediction, and surge. The canonical geo-spatial design problem with hard real-time constraints.
Idempotency keys, double-spend prevention, the ledger model, and why eventual consistency is wrong for balances. The interview where ambiguity costs you money.
Inverted indexes, BM25 ranking, prefix tries, and the p99 < 100ms latency budget that drives every architectural choice.
Fan-out at write vs read, at-least-once vs exactly-once, dead-letter queues, and the multi-channel delivery problem - one message, ten failure modes.
CRDTs vs OT, presence, cursor broadcasting, and conflict-free merging when 50 people edit the same doc at once.
Batch vs streaming, lambda vs kappa, the warehouse-vs-lakehouse decision, and dimension modeling that survives schema drift.
Partitions, consumer groups, replication, retention, and the exactly-once myth - the implementation details Kafka users gloss over until they don't.
Raft leader election, log replication, snapshots - and the CAP theorem in operational practice. The substrate every other distributed system stands on.
Edge cache hierarchies, cache key design, invalidation, origin shield, and edge compute - the system every other system relies on without thinking about it.
L4 vs L7, consistent hashing, health checks, connection draining, and the difference between a fleet that survives partial failures and one that cascades into outage.
The internet's phone book. A globally distributed, read-dominated, cache-everywhere hierarchy that has to answer in single-digit milliseconds and never go down.
The front door to a microservice fleet. One layer that every external request crosses - so it owns auth, rate limiting, routing, and resilience, and absolutely cannot become the bottleneck.
Every HTTPS request starts with a handshake. Terminating TLS for millions of connections - and issuing, rotating, and revoking the certificates behind it - is a system-design problem in its own right.
Two-phase commit, sagas (choreography vs orchestration), TCC, idempotency keys, and the compensation logic that turns multi-service writes into something a customer-support agent can untangle.
Online vs batch inference, GPU utilization tricks, autoscaling for spiky load, A/B testing models, and the feature store that decouples training from serving.
Time-series DBs (Prometheus, M3, VictoriaMetrics), trace sampling, exemplars, OpenTelemetry, alerting, and the cardinality explosion that turns a $10K/month platform into a $1M/month outage.
Redis sorted sets, sharding strategies, real-time vs eventual updates, top-K queries, hot keys, deep pagination - the deceptively-simple problem that breaks at 100M users.
Prefill vs decode, paged KV cache, prompt caching, vector search + reranking, groundedness evals, and why you autoscale on queue depth measured in tokens - not requests.
Namespace vs bytes, erasure coding vs replication, the eleven-nines durability math, multipart upload, and why LIST is the hardest API in the system.
Content-addressed chunks, delta sync, a journal-shaped metadata DB, long-poll notifications to fifty million idle clients, and why last-writer-wins is a lie users notice.
Ten million buyers, five hundred thousand tickets, one contended counter. Virtual waiting rooms, TTL reservations, idempotent payments, and the oversell-vs-throughput dial.
The two-stage candidate-generation-then-ranking architecture, embeddings + ANN retrieval, the batch/real-time feature split, feedback loops, cold start, and why offline NDCG lies until the online A/B disagrees.
The offline/online store split, train/serve skew as the core problem it exists to solve, point-in-time-correct joins, materialization and freshness, and a registry that lets teams reuse features instead of re-deriving them badly.
The sub-100ms auction, candidate ad retrieval, pCTR/pCVR prediction, second- vs first-price auctions, budget pacing, frequency capping, attribution, fraud, and the money-correctness problem of never overspending a budget.
Data ingestion + validation, distributed training (data vs model parallelism), experiment tracking, hyperparameter search, checkpointing + fault tolerance on long runs, the model-registry handoff to serving, reproducibility, and the economics of GPU-cluster utilization.
System design rounds reward depth, not breadth. Memorizing twenty architectures gets you ranked "hire" less often than owning four cold. Each walkthrough is structured the way real interviewers think: clarifying questions first, capacity estimation second, high-level architecture third, then deep-dives into the specific subsystems and trade-offs that decide the score.
Free walkthroughs cover the canonical bounded designs that show up in mid-level loops (URL shortener, news feed). Premium unlocks harder topics that show up at senior+ levels (chat at scale, distributed cache internals). See pricing.
Reading is the floor. The next phase wires each topic to an AI interviewer that walks you through a design and probes follow-ups in real time. Want to suggest a topic? Let us know.