Case Studies
The questions that actually get asked, each worked through the full interview arc: requirements → estimation → API → high-level design → deep dives → rapid MVP implementation with real code → bottlenecks.
Design a URL Shortener (bit.ly)
Design a service that converts long URLs into short, unique aliases and redirects users who visit the alias to the original URL. The core challenges are generating collision-free short codes at scale, serving redirects with very low latency, and handling a read-heavy workload that can be two orders of magnitude larger than writes.
Design a Unique ID Generator (Snowflake)
Design a service that hands out unique, roughly time-sorted 64-bit IDs at high throughput across many machines, in the style of Twitter Snowflake. The core challenge is generating IDs without coordination between nodes while keeping them sortable and collision-free.
Design a Distributed Rate Limiter
Design a service that limits how many requests a client can make in a time window (e.g., 100 requests per minute per user) across a fleet of many API servers. The core challenges are choosing an algorithm with the right burst and accuracy tradeoffs, sharing counter state across servers with low latency, and deciding how the limiter should fail.
Design a Web Crawler
Design a crawler that downloads billions of pages for a search index while being a polite citizen of the web. The core components are a URL frontier that balances priority against per-host politeness, a dedup layer (Bloom filters and content fingerprints), robots.txt compliance, trap avoidance, and a recrawl strategy that keeps the index fresh.
Design Search Autocomplete (Typeahead)
Design a service that suggests the top search queries as a user types each character, like Google Search or Amazon's search box. The core challenge is returning ranked suggestions for any prefix in well under 100ms while keeping the suggestion corpus fresh as query popularity shifts.
Design a Notification System
Design a platform service that delivers notifications to users across push (iOS/Android), email, and SMS on behalf of many internal product teams. The interesting problems are fan-out at scale, deduplication, per-user rate limiting and preferences, and reliable integration with flaky third-party providers like APNs, FCM, and SMS gateways.
Design a Distributed Cache (Redis)
Design a horizontally scalable in-memory key-value cache like Redis or Memcached that sits in front of a database. The interesting problems are how keys map to nodes (consistent hashing), what to evict when memory fills (LRU), how to survive node loss (replication), and how to avoid stampedes and hot keys melting single nodes.
Design a Photo Sharing App (Instagram)
Design a photo sharing service where users upload images, follow each other, and scroll a reverse-chronological feed with likes and comments. The core problems are a reliable upload and resizing pipeline, feed generation at fan-out scale, CDN-fronted delivery, and counters that survive celebrity-level write rates.
Design a Proximity Service (Yelp / Nearby)
A location-based service that returns businesses near a user, sorted by distance and relevance. The core challenge is indexing 2D geospatial data so radius queries stay fast at hundreds of millions of businesses, while keeping business data reasonably fresh.
Design a Distributed Job Scheduler
A service that runs millions of one-off and recurring (cron) jobs on time, distributing work across a fleet of workers with retries, priorities, and at-least-once (approaching exactly-once) execution guarantees, even when schedulers and workers crash mid-flight.
Design a Metrics Monitoring System (Datadog)
Build a system that ingests time-series metrics from thousands of hosts, stores them efficiently with downsampling, supports fast tag-filtered queries, and evaluates alert rules in near real time.
Design a Real-Time Leaderboard
Design a leaderboard for a game with millions of players: instant score updates, exact rank lookups, top-K queries, and neighborhood views, sharded past a single Redis node and hardened against cheaters.
Design a Dating App (Tinder)
A location-based dating app where users swipe right or left on candidate profiles, a match is created when two users like each other, and matched users can chat. The core challenges are generating a fast geo-filtered candidate feed, detecting mutual likes cheaply, and keeping swipe latency low at high write volume.
Design a News Feed (Twitter/Facebook)
Design the system that lets users post content and see a ranked, near-real-time feed of posts from people they follow. The defining challenge is the fan-out problem: how a single post reaches millions of followers' feeds efficiently, and how to blend fan-out on write with fan-out on read to handle celebrity accounts without melting the infrastructure.
Design a Chat System (WhatsApp/Slack)
Design a messaging system supporting one-on-one and group chats with real-time delivery, message ordering, online presence, and read receipts. The core challenges are maintaining millions of long-lived WebSocket connections, routing messages between users connected to different servers, guaranteeing per-conversation ordering, and syncing state across a user's multiple devices.
Design a Video Platform (YouTube/Netflix)
Design a platform where creators upload videos and viewers stream them worldwide. The system splits into an asynchronous upload-and-transcode pipeline and a read-dominated streaming path built on adaptive bitrate protocols (HLS/DASH) and a CDN. The core challenges are parallelizing transcoding, serving petabytes of video with low startup latency, and keeping origin traffic tiny relative to what viewers consume.
Design Ride Sharing (Uber/Lyft)
Design the core of a ride-sharing service: riders request trips, nearby drivers are found and matched in seconds, and both parties track each other live on a map. The hard parts are geospatial indexing of constantly moving drivers, a low-latency matching engine, a massive location-update write load, and dynamic (surge) pricing.
Design a Distributed Key-Value Store (Dynamo)
Design a horizontally scalable, highly available key-value store in the style of Amazon's Dynamo paper (and its descendants Cassandra and Riak). The design tour covers consistent hashing for placement, quorum reads/writes for tunable consistency, vector clocks for conflict detection, hinted handoff and merkle trees for repair, and gossip for membership.
Design Cloud File Storage (Dropbox/Drive)
Design a file hosting service where users upload files, sync them across devices, and share them with others. The core ideas are content-defined chunking, block-level deduplication, delta sync so edits upload only changed chunks, a metadata database that is the real brain of the system, and conflict resolution when two devices edit the same file offline.
Design a Payment System
Design the payment backend for a commerce platform: accept a customer's payment through a PSP like Stripe, record money movement in a double-entry ledger, pay merchants out, and guarantee that retries, crashes, and PSP flakiness never charge anyone twice or lose a cent. Correctness dominates every other concern.
Design a Collaborative Editor (Google Docs)
Design a real-time collaborative text editor where multiple users type into the same document simultaneously and everyone converges to the same content. The heart of the problem is concurrent edit reconciliation (operational transformation vs CRDTs), plus cursor presence, version history, and offline editing.
Design a Search Engine
A web-scale search engine: a polite distributed crawler feeding an inverted-index build pipeline, ranking that blends TF-IDF/BM25 text relevance with PageRank authority, and a sharded, replicated query-serving tier that answers keyword queries over billions of documents in under 200 ms.
Design a Ticket Booking System (Ticketmaster)
A ticketing platform where millions of fans compete for tens of thousands of seats the moment a sale opens. The core problems are correctness (never sell one seat twice) under extreme write contention, temporary seat holds with TTL, and absorbing flash-sale spikes with a virtual waiting room so the transactional core stays within capacity.
Design an Ad Click Aggregator
Count billions of ad clicks per day into minute-level aggregates that advertisers are billed on: stream processing with exactly-once effects, dedup of client retries, late-event handling, and nightly reconciliation against raw logs.
Design a Distributed Message Queue (Kafka)
Design a Kafka-style distributed log: partitioned append-only storage, consumer groups with offset tracking, leader-follower replication with ISR, and the tradeoffs behind at-least-once versus exactly-once delivery and ordering.
Design an Email Service (Gmail)
A web email service that receives mail from the open internet over SMTP, filters spam, stores mailboxes durably, supports fast full-text search over years of mail, and handles attachments. The hard parts are the untrusted ingestion boundary, a multi-stage spam pipeline, storage layout for billions of small messages, and search index freshness.
Design a Digital Wallet
A digital wallet service where users hold balances and transfer money to each other instantly. Money must never be created, destroyed, or double-spent, so the design centers on a double-entry ledger, idempotent transfer operations, distributed transactions when wallets live on different shards, and the ability to audit and rebuild any balance by replaying the event log.
Design Live Streaming (Twitch)
A live streaming platform where creators broadcast video that millions watch with a few seconds of delay, alongside a real-time chat. The pipeline is RTMP ingest, transcoding into a bitrate ladder, HLS segment packaging and CDN delivery, and a chat system whose fan-out can dwarf the video problem. The defining tradeoff is glass-to-glass latency versus scale and cost.