System Design for Interview Prep
You have been grinding LeetCode patterns. System design is the next layer — same thinking, different scale. These articles are written in plain language with real trade-offs, not copied bullet lists. Start with the framework, then work through the case studies.
35 articles · complements our DSA study guide
How to Approach System Design Interviews (Without Panicking)
A practical framework for system design interviews: clarifying requirements, estimating scale, sketching APIs, choosing storage, and discussing trade-offs the way real interviewers expect.
Design a URL Shortener — Complete Interview Walkthrough
Step-by-step system design for a URL shortening service like bit.ly: API design, short-code generation, database schema, caching, redirects, and scaling reads to millions per second.
Design a Distributed Rate Limiter
How to design an API rate limiter for interviews: token bucket vs sliding window, where to enforce limits, Redis Lua scripts, and handling multi-server deployments without race conditions.
Caching Fundamentals Every Interview Candidate Should Know
When to add a cache, cache-aside vs read-through vs write-through, TTL and invalidation, Redis vs CDN, and the consistency traps that catch candidates in system design interviews.
From LeetCode Patterns to Real Systems
How binary search, BFS, heaps, hash maps, and LRU cache problems map to production system design — databases, queues, caches, and load balancers explained for developers who learned DSA first.
SQL vs NoSQL — How to Choose in System Design Interviews
When to pick PostgreSQL vs MongoDB vs Cassandra in interviews: ACID, schema, joins, scale-out, and concrete examples from URL shorteners, feeds, and chat.
Load Balancing and Horizontal Scaling for Interviews
L4 vs L7 load balancers, round-robin vs consistent hashing, health checks, auto-scaling, and how to explain scaling a stateless API tier in system design interviews.
Design a News Feed (Twitter / Instagram Home Timeline)
How to design a social media news feed for interviews: fan-out on write vs fan-out on read, ranking, caching celebrity users, and storage trade-offs.
Design a Chat / Messaging System (WhatsApp / Slack DM)
System design for real-time chat: WebSockets vs polling, message storage, delivery guarantees, online presence, and group chat scaling.
API Design and REST Best Practices for Interviews
How to design REST APIs in system design interviews: resources, HTTP verbs, pagination, versioning, errors, idempotency, and rate-limit headers.
Design a Unique ID Generator (Snowflake, UUID, Auto-Increment)
How to generate globally unique IDs in distributed systems: Snowflake, UUID, database sequences, and trade-offs for system design interviews.
Message Queues and Async Processing (Kafka) for Interviews
When and how to use message queues in system design: Kafka vs RabbitMQ, pub/sub, consumer groups, ordering, and decoupling write paths in interviews.
Design a Notification System (Push, Email, SMS, In-App)
System design for notifications at scale: multi-channel delivery, templates, user preferences, queues, retries, and idempotency for interview prep.
Design a Typeahead / Autocomplete System (Google Search Bar)
System design for search autocomplete: trie vs Elasticsearch, ranking, caching hot prefixes, and handling millions of queries per second in interviews.
Design a File Storage System (Dropbox / Google Drive)
System design for cloud file storage: upload chunking, metadata vs blob storage, sync, conflict resolution, and CDN delivery for interviews.
Design a Web Crawler (Google Search Bot)
System design for a web crawler at scale: URL frontier, politeness, deduplication, DNS, and distributed fetching for interview prep.
Design a Ride Hailing System (Uber / Lyft)
System design for ride matching: geospatial indexing, ETA, surge pricing, trip state machine, and real-time location for interview prep.
CAP Theorem and Consistency Models for Interviews
CP vs AP trade-offs, strong vs eventual consistency, linearizability, and when to pick each in system design interviews.
Database Sharding and Replication for Interviews
How to shard relational and NoSQL databases: shard keys, consistent hashing, read replicas, failover, and rebalancing in system design interviews.
Design a Payment System (Stripe / PayPal)
System design for payments: idempotency, ledger, authorization vs capture, PCI scope, and exactly-once money movement for interviews.
Design a Video Streaming Platform (Netflix / YouTube)
System design for video streaming at scale: upload pipeline, transcoding, adaptive bitrate, CDN delivery, and playback APIs for interview prep.
Design a Search Engine (Google)
System design for web search: inverted index, query processing, ranking, autocomplete, and scaling reads to billions of queries for interview prep.
Design a Ticket Booking System (Ticketmaster)
System design for concert and event ticketing: seat inventory, distributed locking, payment hold, and handling flash-sale traffic for interviews.
Design a Distributed Cache (Redis)
How to design Redis-like distributed caching: consistent hashing, replication, eviction, cache stampede, and when to use cache-aside in system design interviews.
Design an E-Commerce Platform (Amazon)
System design for online shopping: product catalog, inventory, cart, checkout, order fulfillment, and scaling browse vs buy paths for interviews.
Design Pastebin (Text Sharing Service)
How to design Pastebin for interviews: short URL generation, paste storage, expiration, access control, and scaling read-heavy text sharing with object storage and caching.
Design a Real-Time Leaderboard
How to design a gaming or app leaderboard for interviews: Redis sorted sets, score updates, top-K queries, sharding by game, and handling ties at scale.
Design an API Gateway
How to design an API gateway for interviews: routing, auth, rate limiting, SSL termination, request transformation, and how it differs from a load balancer.
Design Google Docs (Collaborative Editor)
How to design a real-time collaborative document editor for interviews: operational transform vs CRDT, WebSockets, presence, versioning, and conflict resolution at scale.
Design Instagram (Photo Sharing)
How to design a photo sharing app like Instagram for interviews: media upload pipeline, CDN delivery, news feed integration, likes, and scaling image-heavy social traffic.
Design Airbnb (Hotel / Home Booking Marketplace)
How to design Airbnb for interviews: listing search, availability calendar, booking holds, payments, host/guest flows, and scaling a two-sided marketplace.
Design a Distributed Job Scheduler (Cron at Scale)
How to design a distributed job scheduler for interviews: cron expressions, durable job store, worker fleets, at-least-once execution with idempotent handlers, retries, and avoiding thundering herds.
Design a Distributed Key-Value Store
How to design a Dynamo-style key-value store for interviews: partitioning, replication, consistency, gossip, hinted handoff, and CAP trade-offs.
Design Yelp (Nearby Places / Local Search)
How to design Yelp-style nearby search for interviews: geospatial indexing, geohashes, ranking, reviews, and scaling location-based queries.
Design Zoom (Video Conferencing)
How to design Zoom-style video conferencing for interviews: WebRTC, SFU vs MCU, media servers, signaling, recording, and scaling multiparty calls.
Suggested reading order
- How to Approach System Design Interviews — learn the 45-minute framework first
- Design a URL Shortener — classic case study end to end
- Caching Fundamentals — you will need this on almost every design
- Design a Rate Limiter — distributed state and atomicity
- From LeetCode Patterns to Real Systems — connect what you already know
- SQL vs NoSQL — pick the right store for each component
- Load Balancing and Horizontal Scaling — scale the app tier correctly
- Design a News Feed — fan-out on write vs read and the celebrity problem
- Design a Chat / Messaging System — WebSockets, delivery, and groups
- API Design and REST Best Practices — endpoints interviewers expect you to name
- Design a Unique ID Generator — Snowflake, UUID, and when to use each
- Message Queues and Async Processing — Kafka, ordering, and idempotent consumers
- Design a Notification System — push, email, SMS, and idempotency
- Design Typeahead / Autocomplete — trie, ranking, and hot-prefix caching
- Design File Storage (Dropbox) — chunked upload, metadata vs blobs, sync
- Design a Web Crawler — URL frontier, politeness, and deduplication
- Design Ride Hailing (Uber) — geospatial matching and trip state machine
- Design a Payment System — idempotency, ledger, and authorize/capture
- CAP Theorem and Consistency Models — CP vs AP per component
- Database Sharding and Replication — shard keys, replicas, and hot spots
- Design a Video Streaming Platform (Netflix) — transcoding, HLS, and CDN delivery
- Design a Search Engine — inverted index, ranking, and query fan-out
- Design a Ticket Booking System — seat holds, flash sales, and strong consistency
- Design a Distributed Cache (Redis) — consistent hashing, eviction, and stampede
- Design an E-Commerce Platform — catalog, cart, inventory, and checkout
- Design Pastebin — text storage, expiration, and read-heavy caching
- Design a Real-Time Leaderboard — Redis sorted sets and top-K queries
- Design an API Gateway — auth, routing, and rate limits at the edge
- Design Google Docs — OT/CRDT, WebSockets, and collaborative editing
- Design Instagram — photo upload, CDN, and feed at scale
- Design Airbnb — listings, availability calendar, and booking holds
- Design a Distributed Job Scheduler — cron at scale, locks, and retries
- Design a Key-Value Store — consistent hashing, quorum, and replication
- Design Yelp — geohash nearby search and local ranking
- Design Zoom — WebRTC, SFU media servers, and signaling