[reference / practice] — applying the framework to the classic design problems. The point isn’t to memorize “the answer” (there isn’t one) — it’s to practice the reasoning, since that’s what the skill and the interview reward.

How to use these

For each problem, run the framework: clarify requirements → estimate → high-level design → deep-dive the hard part → name the tradeoffs. Do it on paper/whiteboard before reading any solution. The classic problems each stress a different building block:

URL shortener (e.g. bit.ly)

  • The core — generate a short unique key for a long URL; redirect on lookup.
  • What it teaches — key generation (ID strategies: hash vs counter vs random, collision handling), read-heavy caching (redirects vastly outnumber creates), and simple key-value storage at scale. The gentle starter.

A social feed / Twitter timeline

  • The core — users post; followers see a timeline.
  • What it teaches — the fan-out decision: fan-out-on-write (push each post to all followers’ precomputed timelines — fast reads, expensive for celebrities with millions of followers) vs fan-out-on-read (assemble the timeline at read time — cheap writes, slow reads). The real answer is hybrid (push for most, pull for celebrities) — a perfect example of “it depends on the requirements.” Also caching, sharding by user, and eventual consistency (a slightly stale feed is fine).

A rate limiter

  • The core — allow N requests per user per window; reject the rest.
  • What it teaches — algorithms (token bucket, sliding window), where the counter lives (Redis for shared state across servers), and the concurrency of atomic increments. You’ve already got a single-machine version to build — the distributed version adds shared state.

A chat system (e.g. WhatsApp)

  • The core — real-time messaging, delivery, presence.
  • What it teaches — WebSockets for real-time push, message queues, delivery guarantees + idempotency (exactly-once display), and connection state at scale.

Others worth working

A news feed / notification system (fan-out again), a web crawler (queues, dedup, politeness), a typeahead/autocomplete (tries, caching), a distributed cache (consistent hashing), a payment system (strong consistency, idempotency, sagas — the domain you’ve built in Java).

The evaluation criteria (what “good” looks like)

Whether interviewing or designing for real, a strong design shows:

  1. Requirements first — you asked what you’re optimizing for before designing.
  2. Justified choices — every component has a why tied to a requirement, not “because it’s what people use.”
  3. Named tradeoffs — you said what you’re giving up (consistency for availability, storage for read speed) deliberately.
  4. Bottleneck awareness — you found the single points of failure and hot paths and addressed them.
  5. Knowing when to stop — you didn’t add Kafka and microservices to a problem a monolith and a database solve.

Then: build one

Reading and whiteboarding get you far, but the deepest understanding comes from building — which is why the flagship projects are systems you implement yourself. Design a system on paper, then go build a piece of it for real.

↑ Back to 05 — Case Studies & Practice