System Design Use Cases

FAANG-manager structure for functional/non-functional requirements, entities, API, and level-specific depth.

Alex Xu’s four-step process — clarify, high-level, deep dive, wrap-up — with emphasis on collaboration over memorized diagrams.

Repeatable whiteboard template from the original Grokking authors — good checklist before diving into any case.

Companion to the master template — how to pace a full round without skipping trade-offs.

Power-of-two math, daily active users → QPS, storage growth — the canonical numbers interviewers expect.

Quick estimation drills tied to scalability trade-offs — good if you want Grokking-style framing.

Vertical → horizontal → DB replication → cache → CDN progression — maps estimates to architecture phases.

Staff-engineer pattern catalog with links into problem breakdowns — use as index before practicing cases.

Rubric (problem navigation, solution design, technical excellence, communication) and level expectations.

How Staff loops differ — drive ambiguity, multi-region, org-level trade-offs, not just bigger diagrams.

Structured trade-off lessons (consistency, cache strategies, REST vs RPC) — interview vocabulary drill.

Classic Alex Xu walkthrough — algorithms, middleware placement, and distributed consistency pitfalls.

Grokking case study — KGS-style thinking, sliding window log, and where to terminate TLS vs app layer.

Level-by-level expectations (mid/senior/staff) and deep dives on Redis cell vs centralized counter.

Twitter Snowflake-style bit layout — the reference answer for 'how do we generate sortable IDs at scale?'

Shorter Grokking variant — good warm-up before Snowflake deep dive.

CAP, consistency models, vector clocks, hinted handoff — ties directly to your Distributed Systems track.

Staff-depth paper walkthrough — vector clocks, Merkle trees, sloppy quorum. Read after ByteByteGo ch. 7.

Free structured solution with links into primer topics — good sanity check after paid material.

Ring mechanics and redistribution cost when nodes join/leave — prerequisite for cache and KV designs.

Queue-based workers, rate limits per provider, and deduplication — common Staff follow-up thread.

Grokking variant with template service and analytics — compare channel prioritization choices.

Medium difficulty with cluster sharding and hot-key mitigation — bridges Databases Redis topic to HLD.

Explicit mid/senior/staff bars — good first timed practice after methodology sections.

Base-62 vs hash collision handling and cache placement — compare redirect semantics with Hello Interview.

Key Generation Service (KGS) pre-allocation pattern — unique angle vs hash-based designs.

Free solution with MD5/Base62 math and capacity exercises — good for estimation drill.

Blob storage for large pastes, expiration TTLs, and custom URLs — natural follow-up to URL shortener.

Hard-rated breakdown — block store, notification of changes, and multi-device sync at Senior depth.

Same problem class as Dropbox — compare chunk size, sync vs async upload, and conflict policies.

Grokking walkthrough with acid metadata + eventually consistent blob tier.

ByteByteGo Vol. 2 case — metadata vs data nodes, consistency, and lifecycle policies.

Medium difficulty with explicit celebrity/hybrid fan-out deep dives — must-do before Instagram variant.

Push vs pull vs hybrid with consistent hashing for hot keys — classic Alex Xu treatment.

Grokking feed generation with sharded feed tables — compare ranking placement with Hello Interview.

Free condensed narrative — good pre-read before paid deep dives.

Links into primer topics (cache, sharding, fan-out) — use as checklist after structured courses.

Historical production architecture — useful for 'how did real systems evolve?' Staff color.

Medium difficulty — ties feed fan-out to image upload and CDN delivery paths.

News feed generation with media metadata sharding — compare with pure feed case above.

Tweet ingestion, timeline fan-out, and retweet graph — pair with Twitter Search below.

Hard-rated — Elasticsearch-style indexing with social graph constraints.

Full-text search, early binding vs late binding — complementary to FB post search.

Medium difficulty — isolation, resource limits, and async grading pipeline.

Container-based runner fleet and verdict state machine.

Medium difficulty with message queue and presence deep dives — classic Meta loop question.

WebSocket fan-out, group chat partitioning, and storage schema for messages.

Online status, sync across devices, and media messages — compare delivery guarantees.

Hard-rated — realtime updates pattern, storage growth, million-connection scaling.

Medium difficulty — spike traffic, ordering, and spam filtering at live scale.

Medium difficulty with transcoding and view count deep dives.

DAG transcoding model, blob storage, CDN streaming path — excellent Staff-depth diagrams.

Grokking treatment of upload vs watch paths and popular content caching.

Hard-rated — heavy hitters, count-min sketch, and distributed aggregation.

Free Top-K style ranking solution — good pairing with Hello Interview hard case.

Data structure choices and aggregation of trending queries.

Grokking prefix index + personal vs global suggestions.

Hard-rated Google-style crawler with URL frontier and bloom-filter dedup.

Robots.txt, priority queues, and checksum dedup — compare politeness strategies.

Grokking BFS frontier and DNS resolution bottlenecks.

Free solution with modular topic links.

Medium difficulty Google News-shaped case.

Clustering duplicate stories and topic classification pipeline.

Hard-rated with geospatial deep dives and dispatch fairness — must-do Senior case.

Quadtree/geohash matching and WebSocket location updates.

Geospatial index primitive extracted — read before or after full Uber case.

Location update stream + geohash sharding — lighter geo warm-up.

Easy-rated entry to geospatial design — good before Uber.

Geospatial index + business metadata sharding.

Medium difficulty — distributed locks vs queue-based allocation for hot events.

Grokking treatment of seat map partitioning and oversell prevention.

Concurrency on room-night inventory — pairs with Ticketmaster contention patterns.

Optional Staff+ case — map tile CDN and routing service decomposition.

Hard-rated — workflow state machine, exactly-once money movement, audit trail.

ByteByteGo Vol. 2 — PSP integration, idempotency keys, and settlement batching.

Grokking hard case — ledger DB and fraud scoring hook.

Hard-rated fintech case — order book, real-time quotes, and trade lifecycle.

Matching engine and market data distribution — infra view of trading systems.

Medium difficulty — optimistic locking vs serialized lot updates.

Ledger + wallet service split — read after Payment System case.

Hard-rated — complements your in-repo Observability track with HLD assembly.

Kafka ingestion, TSDB storage tier, and alert evaluator fleet.

Medium difficulty — overlaps Data Engineering orchestration topic from HLD angle.

End-to-end MQ design — read alongside Distributed Systems messaging topic.

Staff-depth paper-style Kafka module — controller, ISR, delivery semantics.

Hard-rated — stream processing + idempotent aggregation for revenue.

Lambda/kappa style pipelines for click counts — DE-relevant Staff case.

Hard Grokking case — inventory contention, spike traffic, and checkout coupling; overlaps price-drop alert systems.

Ingestion queues, blob storage for attachments, and search index.

Grokking medium case — conversation threading and label index.

Medium Grokking case — ML-adjacent product design without training math.

Deep module — read after KV store and your Databases wide-column topic.

Google File System paper walkthrough — foundation for Bigtable/HDFS modules.

Hadoop-era DFS — compare with GFS and your Data Engineering lake storage topic.

Staff paper depth — read after GFS module.

Hard-rated modern case — pairs with in-repo AI Systems track for depth.

Redis sorted sets vs dedicated ranking service — fast Staff warm-up.