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.
65 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.
Design Spotify (Music Streaming)
How to design Spotify for interviews: music catalog, audio CDN delivery, playlists, search, recommendations sketch, and scaling play-count writes.
Design Google Maps (Navigation & Places)
How to design Google Maps for interviews: map tiles, geospatial indexing, routing/ETA, traffic updates, and place search at global scale.
Design a Metrics Monitoring System (Prometheus-style)
How to design a metrics and monitoring system for interviews: metric ingestion, time-series storage, aggregation, alerting, dashboards, and cardinality explosions.
Design a Distributed Lock Service
How to design a distributed lock for interviews: lease-based locks, Redis vs ZooKeeper vs etcd, fencing tokens, deadlock avoidance, and split-brain risks.
Design an Online Code Judge (LeetCode-style)
How to design an online judge for interviews: code submission, sandboxed execution, judging queues, plagiarism, and scaling contest load spikes.
Design an Email Service (Gmail)
How to design Gmail for interviews: SMTP ingest, mailbox storage, search indexing, spam filtering, push sync, and multi-device consistency.
Design a Recommendation System
How to design a recommendation system for interviews: candidate generation, ranking, features, offline training, online serving, and feedback loops.
Design a Stock Trading Platform
How to design a stock trading system for interviews: market data, order gateway, matching engine sketch, ledger, risk checks, and low-latency paths.
Design a Food Delivery App (DoorDash)
How to design DoorDash / Uber Eats for interviews: restaurant catalog, cart and checkout, courier dispatch, ETA, live tracking, and peak-hour scaling.
Design a Q&A Platform (Stack Overflow)
How to design Stack Overflow / Quora for interviews: questions and answers, voting, reputation, full-text search, caching hot posts, and moderation.
Design a CDN (Content Delivery Network)
How to design a CDN for interviews: edge PoPs, cache hierarchy, origin shield, cache keys, invalidation, and anycast routing.
Design Live Streaming (Twitch)
How to design Twitch-style live streaming for interviews: ingest, transcoding, HLS/LL-HLS, CDN fan-out, chat, and failure handling.
Design a Distributed Logging System
How to design distributed logging for interviews: agents, collectors, Kafka buffers, indexing, retention, query APIs, and alert hooks.
Design an Ad Click Aggregator
How to design an ad click aggregator for interviews: impression/click ingest, dedupe, real-time counters, batch warehouses, and fraud-light filters.
Design Google Calendar
How to design Google Calendar for interviews: events and recurrence, availability, invites, reminders, sync, and concurrency on overlapping edits.
Design Object Storage (Amazon S3)
How to design S3-style object storage for interviews: buckets and keys, multipart upload, erasure coding vs replication, metadata indexes, consistency, and CDN egress.
Design a DNS System
How to design DNS for interviews: hierarchy, recursive vs authoritative resolvers, caching TTLs, anycast, zone updates, DNSSEC basics, and failure modes.
Design an Authentication System (OAuth / SSO)
How to design authentication and SSO for interviews: sessions vs JWTs, OAuth 2.0 / OIDC flows, refresh tokens, MFA, logout, and multi-tenant identity.
Design a Webhook Delivery System
How to design reliable webhook delivery for interviews: signed payloads, at-least-once retries, backoff, fan-out queues, endpoint health, and idempotency keys.
Design a Service Discovery System
How to design service discovery for interviews: client-side vs server-side discovery, registries (Consul/etcd), health checks, DNS vs push watch, and consistency trade-offs.
Design a Feature Flag System
How to design feature flags for interviews: boolean and percentage rollouts, targeting rules, SDK polling vs streaming, kill switches, audit logs, and consistency.
Design an A/B Testing Platform
How to design A/B testing for interviews: experiment assignment, sticky bucketing, metrics pipelines, sequential testing pitfalls, exposure logging, and SRM checks.
Design a Bloom Filter Service
How to design Bloom filters for interviews: false positives, bit array sizing, k hash functions, counting/scalable variants, Redis bitmaps, and classic use cases.
Design a Distributed Counter
How to design distributed counters for interviews: Redis INCR, sharded counters, CRDTs, approximate counts, write buffering, and read-your-writes trade-offs.
Design MapReduce (Batch Processing)
How to design MapReduce for interviews: map/shuffle/reduce, fault tolerance, speculative execution, schedulers, YARN/HDFS overlap, and when Spark wins.
Design a Circuit Breaker
How to design circuit breakers for interviews: closed/open/half-open states, failure thresholds, bulkheads, timeouts, fallbacks, and where they sit vs retries and rate limits.
Design a Configuration Service
How to design a config service for interviews: versioned keyspaces, environments, push vs poll, validation, rollbacks, caching at the edge, and audit trails.
Design a Secrets Manager
How to design a secrets manager for interviews: envelope encryption, rotation, least-privilege access, audit logs, dynamic DB credentials, and break-glass flows.
Design a Health Check / Status System
How to design health checks for interviews: liveness vs readiness, dependency probes, status pages, aggregation, flapping control, and load balancer integration.
Design Distributed Transactions (Saga / 2PC)
How to design distributed transactions for interviews: 2PC vs Saga, choreography vs orchestration, compensations, idempotency, and when to avoid cross-service ACID.
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
- Design Spotify - audio CDN, playlists, and play-event pipelines
- Design Google Maps - tiles, routing, and live traffic
- Design a Metrics Monitoring System - TSDB, labels, and alerting
- Design a Distributed Lock - leases, Redis vs ZooKeeper, fencing
- Design an Online Code Judge - sandboxes, queues, and contests
- Design an Email Service (Gmail) - SMTP ingest, mailbox sharding, and search
- Design a Recommendation System - candidate generation, ranking, and feedback loops
- Design a Stock Trading Platform - orders, risk, ledger, and market data
- Design Food Delivery (DoorDash) - dispatch, ETA, and three-sided marketplace
- Design a Q&A Platform (Stack Overflow) - votes, reputation, and hot-post caching
- Design a CDN - edge PoPs, origin shield, and cache invalidation
- Design Live Streaming (Twitch) - ingest, transcode, HLS, and chat
- Design a Distributed Logging System - agents, Kafka buffers, and hot/cold tiers
- Design an Ad Click Aggregator - event ingest, dedupe, and billing-grade batch
- Design Google Calendar - recurrence, invites, reminders, and sync
- Design Object Storage (S3) - metadata vs bytes, multipart, erasure coding
- Design a DNS System - recursive vs authoritative, TTLs, and anycast
- Design Authentication (OAuth / SSO) - sessions vs JWTs, PKCE, refresh
- Design a Webhook Delivery System - signed POSTs, backoff, and DLQ
- Design Service Discovery - registries, leases, and client vs server-side
- Design a Feature Flag System - targeting, sticky rollouts, and kill switches
- Design an A/B Testing Platform - assignment, exposure logs, and SRM
- Design a Bloom Filter Service - probabilistic membership and sizing
- Design a Distributed Counter - sharding, CRDTs, and hot keys
- Design MapReduce - map, shuffle, reduce, and fault tolerance
- Design a Circuit Breaker - closed, open, half-open, and bulkheads
- Design a Configuration Service - versioned snapshots and rollbacks
- Design a Secrets Manager - envelope encryption and rotation
- Design Health Checks / Status - liveness vs readiness
- Design Distributed Transactions - 2PC vs Saga compensations