Interview Scenarios

Full end-to-end system design walkthroughs using the same 8-step framework that top candidates use. Each scenario is a real interview question — practice them until the framework becomes second nature.

The 8-Step Framework

1. Requirements
2. Estimation
3. High-Level Design
4. Component Deep Dive
5. Database Schema
6. API Design
7. Scalability
8. Monitoring
Scenarios completed0/40(0%)

Design URL Shortener (TinyURL)

Design a URL shortening service like TinyURL or bit.ly. Given a long URL, the system generates a short, unique alias that redirects users to the original URL. This deceptively simple problem tests your ability to reason about hashing, distributed ID generation, caching at scale, and back-of-envelope math — all core system design skills.

45 minutes
Start

Design Twitter / X Feed

Design a social media platform like Twitter/X where users can post short messages (tweets), follow other users, and view a personalized home timeline. The core engineering challenge is the fanout problem: when a user with 50 million followers posts a tweet, how do you deliver it to all those followers' timelines in near real-time? This is not a CRUD app — it is a distributed systems problem that touches caching, message queues, graph databases, and the fundamental trade-off between write amplification and read amplification. Getting the fanout strategy right is what separates a junior answer from a senior one.

45-60 minutes
Start

Design WhatsApp / Messenger

Design a real-time messaging system like WhatsApp that supports 1:1 messaging, group chats, delivery receipts (sent/delivered/read), online presence, and media sharing for 2 billion users. This is one of the most demanding system design problems because it combines persistent WebSocket connections at massive scale, strict message ordering, exactly-once delivery semantics, and offline message queuing — all while maintaining sub-200ms end-to-end latency for users on opposite sides of the planet.

Premium Access
Sign in

Design YouTube / Netflix

Design a large-scale video streaming platform like YouTube or Netflix. This is one of the most challenging system design problems because it spans two fundamentally different subsystems: an asynchronous upload-and-transcoding pipeline (write path) and a latency-sensitive streaming path (read path). The CDN is the single most important component — over 90% of all bytes served originate from edge servers, not your origin. You must reason about massive storage (750 TB+ ingested daily), GPU-bound transcoding, adaptive bitrate delivery, and a metadata layer that handles billions of daily queries.

Premium Access
Sign in

Design Instagram

Design a photo and video sharing social network like Instagram that supports uploading media, following other users, generating a personalized feed, and ephemeral Stories. Instagram is the canonical read-heavy media platform: for every photo uploaded, it is viewed thousands of times. This means CDN placement and feed caching dominate the architecture. You will also tackle hybrid fanout (the same technique Twitter uses), a multi-resolution image processing pipeline, and a Stories subsystem with automatic 24-hour TTL expiration.

Premium Access
Sign in

Design Uber / Lyft

Design a ride-hailing platform that matches riders with nearby drivers in real time, tracks live driver locations at massive scale (1.5M updates/sec), calculates dynamic surge pricing, and manages the full trip lifecycle from request to payment. This is one of the most technically demanding system design questions because it requires real-time geospatial indexing, sub-second matching, and a globally distributed architecture that handles millions of concurrent mobile connections.

Premium Access
Sign in

Design Dropbox / Google Drive

Design a cloud file storage and synchronization service like Dropbox or Google Drive. Users can upload, download, and sync files across multiple devices with near-instant propagation. The system must handle block-level delta sync, deduplication, and conflict resolution at massive scale — 700M+ users storing petabytes of data.

Premium Access
Sign in

Design Amazon E-Commerce

Design a large-scale e-commerce platform that supports product browsing, search, shopping cart management, checkout with payments, and order fulfillment. The system must handle 300 million products, millions of orders per day, and extreme traffic spikes during events like Black Friday — all while guaranteeing inventory correctness so no customer ever pays for an item that is already sold out.

Premium Access
Sign in

Design Rate Limiter

Design a distributed rate limiter that sits in front of your API servers and throttles requests based on configurable rules. Rate limiting is the first line of defense against abuse, DDoS attacks, and accidental traffic spikes. Every API at scale needs one, and interviewers love this question because it forces you to reason about distributed state, atomicity, clock precision, and graceful degradation. You will design a system that supports multiple algorithms, multi-level rules (per-user, per-API-key, per-IP, global), and works correctly across a fleet of API servers backed by a shared Redis cluster.

Premium Access
Sign in

Design Notification System

Design a scalable notification system that delivers messages across multiple channels — push notifications (iOS/Android), SMS, email, and in-app. The system must handle millions of events per day, respect user preferences, de-duplicate messages, and prioritize delivery based on urgency. This is one of the most commonly asked system design questions because every major product has a notification layer, and interviewers want to see you reason about event-driven architecture, fan-out, and third-party integrations.

Premium Access
Sign in

Design Web Crawler

Design a distributed web crawler that can download and process 1 billion web pages per day. The crawler must respect robots.txt, avoid re-crawling duplicate content, prioritize important pages, enforce politeness policies (rate limits per domain), and schedule re-crawls to keep content fresh. This is one of the hardest system design questions because it touches on nearly every distributed systems concept: coordination, fault tolerance, deduplication, priority scheduling, and massive-scale I/O.

Premium Access
Sign in

Design Typeahead / Autocomplete

Design a typeahead (autocomplete) system like Google Search Suggestions. As a user types each character, the system returns the top-K most relevant suggestions in real time. This problem tests your ability to design low-latency query systems with trie-based data structures, precomputed ranking, multi-layer caching, and a pipeline that continuously learns from billions of search queries per day. The system must blend global popularity with personalized user signals — all within a p99 latency budget of 100ms.

Premium Access
Sign in

Design Distributed Cache

Design a distributed caching system like Redis Cluster or Memcached that can serve 100M+ requests per second with sub-millisecond p99 latency. This is an infrastructure-level question that tests your understanding of consistent hashing, cache coherence, replication, eviction policies, hot key mitigation, and failure recovery. Unlike application-level design questions, this one demands precise reasoning about memory management, network topology, and data placement strategies. Interviewers love this question because every wrong assumption is immediately exposed by the math.

Premium Access
Sign in

Design Chat System

Design a large-scale real-time chat system supporting 1-on-1 conversations, group chats, read receipts, typing indicators, presence (online/offline/last seen), offline message delivery, message search, and end-to-end encryption. This is one of the most demanding system design problems because it requires reasoning about persistent WebSocket connections at massive scale (500M concurrent), reliable message delivery with ordering guarantees, fan-out strategies for group chats, and a store-and-forward architecture for offline users. Every major tech company has asked a variant of this question.

Premium Access
Sign in

Design Social Graph

Design the social graph infrastructure behind a platform like Facebook or LinkedIn — the system that stores who is connected to whom and answers graph queries in real time. At 3 billion users and 500 billion friendship edges, this is one of the largest data structures ever built. The system must support friend lookups, mutual friend computation, friend-of-friend BFS traversal, and a 'People You May Know' recommendation pipeline — all with sub-100ms latency. This problem tests your ability to reason about graph storage models, distributed graph partitioning, caching strategies for power-law degree distributions, and offline/online hybrid architectures.

Premium Access
Sign in

Design Metrics & Monitoring System

Design a distributed metrics and monitoring system like Datadog, Prometheus, or Amazon CloudWatch. The system must ingest millions of metrics per second from instrumented applications, store them efficiently in a time-series database, support flexible queries and dashboards, and trigger alerts based on SLI/SLO thresholds. This problem tests deep knowledge of time-series data modeling, push vs. pull collection architectures, aggregation pipelines, percentile computation at scale, and the full alerting lifecycle — from threshold detection to notification delivery.

Premium Access
Sign in

Design Task Queue

Design a distributed task queue system like Celery, Sidekiq, or Amazon SQS. Producers submit tasks (jobs) to a queue, and a fleet of workers picks them up and executes them reliably. The system must guarantee delivery even when workers crash, support priority scheduling and delayed execution, retry failed tasks with exponential backoff, and scale to 1 million tasks per minute. This question tests your understanding of message delivery guarantees, distributed locking, idempotency, and horizontal scaling — skills that underpin every large-scale backend system.

Premium Access
Sign in

Design Video Conferencing

Design a large-scale video conferencing system like Zoom, Google Meet, or Microsoft Teams. This is one of the hardest system design problems because it demands real-time media delivery with sub-150ms end-to-end latency, sophisticated NAT traversal via STUN/TURN, a media routing architecture (SFU vs MCU), adaptive quality control that responds to bandwidth fluctuations within milliseconds, and screen sharing — all operating simultaneously across hundreds of millions of daily participants. The system straddles two worlds: a signaling plane (lightweight, reliable, eventually consistent) and a media plane (high-throughput, ultra-low-latency, tolerant of packet loss). Getting the boundary between these two planes right is the key architectural decision.

Premium Access
Sign in

Design Key-Value Store

Design a distributed key-value store like Amazon DynamoDB, Apache Cassandra, or Riak. The system must store billions of key-value pairs across a cluster of commodity machines, handle 10 million operations per second, and maintain 99.99% availability — even during node failures, network partitions, and rolling deployments. This is one of the hardest system design questions because it forces you to reason about the CAP theorem in practice: how do you balance consistency, availability, and partition tolerance when the network is unreliable? You will design an LSM-tree based storage engine, a consistent hashing ring for data distribution, Dynamo-style quorum replication, a gossip protocol for cluster membership, and conflict resolution using vector clocks.

Premium Access
Sign in

Design Collaborative Editor

Design a real-time collaborative document editor like Google Docs or Notion. Multiple users can simultaneously edit the same document, see each other's cursors and selections in real time, and resolve conflicts seamlessly — even when some users are offline. This problem is genuinely hard because it sits at the intersection of distributed systems theory (consistency, ordering, conflict resolution), real-time networking (WebSockets, presence), and practical UX (the user must never see a glitch, stale cursor, or lost keystroke). Interviewers use this question to test deep systems thinking, not just box-and-arrow architecture.

Premium Access
Sign in

Design Pastebin

Design a text-sharing service like Pastebin, GitHub Gists, or Hastebin. Users paste text content (code snippets, logs, configuration files), receive a unique short URL, and anyone with that URL can view the content — optionally with syntax highlighting. This question tests your ability to design a content-addressable storage system, reason about deduplication, handle variable-size objects efficiently, and implement TTL-based expiration at scale.

Premium Access
Sign in

Design Netflix

Design a video streaming platform like Netflix that serves 250M+ subscribers across 190 countries. The system must handle video upload and transcoding, adaptive bitrate streaming, a personalized recommendation engine, and a global CDN that accounts for 15% of all downstream internet traffic in the US. This is one of the hardest system design questions because it spans every layer of the stack: massive storage (petabytes of video), compute-intensive transcoding, real-time adaptive streaming, machine learning recommendations, and a custom CDN architecture (Open Connect) that pushes content to the edge of ISP networks.

Premium Access
Sign in

Design Facebook News Feed

Design the Facebook News Feed — the centerpiece of the world's largest social network. When a user opens Facebook, they see a personalized feed of posts from friends, pages, and groups they follow, ranked by an ML model that predicts engagement. This is not a simple reverse-chronological timeline — it is a full ranking pipeline that evaluates thousands of candidate stories, scores each one across hundreds of features, and returns the top 50 in under 200ms. The system must handle 3 billion registered users (1 billion DAU), 10,000+ new posts per second, a hybrid fan-out strategy to solve the celebrity problem, real-time content moderation that blocks policy-violating content before it reaches any feed, and aggregation of related stories (e.g., '5 friends liked this'). Getting the ranking architecture right — and explaining how it interacts with fan-out, aggregation, and content integrity — is what separates a strong answer from a mediocre one.

Premium Access
Sign in

Design a Search Engine

Design a web-scale search engine like Google. The system crawls the web to discover pages, builds a massive inverted index over 100B+ documents, processes user queries by looking up matching documents and ranking them by relevance, and returns the top 10 results in under 500ms. This is one of the most complex distributed systems ever built — it touches every fundamental concept in systems design: distributed storage, MapReduce-style batch processing, inverted indexes, relevance scoring (TF-IDF, BM25, PageRank), caching at multiple layers, and the critical sharding decision (partition by document vs. partition by term). The interview conversation will likely focus on the indexing pipeline and the query serving path — two very different systems with different latency requirements, scaling challenges, and failure modes. Getting the inverted index design right and articulating the document-vs-term sharding trade-off is what demonstrates senior-level understanding.

Premium Access
Sign in

Design a Distributed File System

Design a distributed file system like Google File System (GFS) or Hadoop Distributed File System (HDFS) capable of storing petabytes of data across thousands of commodity machines. The system must handle very large files (multi-GB to TB), optimize for sequential read/write throughput (batch analytics, MapReduce), and tolerate frequent hardware failures without data loss. This is a foundational infrastructure question that tests your ability to reason about single-master coordination, chunk-based data distribution, replication placement, consistency trade-offs, and the real-world operational challenges of running storage at planet scale. Google's original GFS paper (2003) and HDFS are the gold standards — interviewers expect you to know the architecture cold and articulate why each design decision was made.

Premium Access
Sign in

Design a Distributed Logging System

Design a distributed logging system that collects, aggregates, indexes, and enables searching across logs from thousands of application servers — similar to the ELK stack (Elasticsearch, Logstash, Kibana), Splunk, or Datadog Logs. The system must ingest 500 TB of logs per day (10 million log events per second at peak), provide sub-10-second search latency across petabytes of indexed data, and support structured queries, full-text search, and log correlation via trace IDs. This is a bread-and-butter infrastructure question that tests your ability to design high-throughput data pipelines, make trade-offs between indexing cost and query speed, and reason about retention policies that balance storage cost with operational needs. Every production system at scale has a logging pipeline — interviewers expect you to understand how it works end to end.

Premium Access
Sign in

Design Analytics Dashboard

Design a large-scale analytics dashboard platform like Grafana or Datadog Dashboards. Users create dashboards containing panels (charts, tables, heatmaps, gauges) that query diverse data sources (Prometheus, InfluxDB, Elasticsearch, PostgreSQL, CloudWatch) and render real-time or historical visualizations. The core challenge is query federation — a single dashboard may query 5 different backends with different query languages, latencies, and data models, and the results must be unified, transformed, and rendered in under 2 seconds. The system must support 100K+ dashboards viewed concurrently, real-time refresh via WebSocket push at 5-30 second intervals, multi-tenant isolation with fine-grained RBAC, and an alerting engine that evaluates thousands of alert rules per second against streaming data. This is a 'wide and deep' system design problem that tests your ability to compose many subsystems into a coherent product.

Premium Access
Sign in

Design a Config Management System

Design a centralized configuration management system that serves 100K microservice instances with 1M config reads per second, propagating changes to all clients within 100ms. This is the nervous system of a microservices architecture — every service needs configuration (database URLs, feature flags, rate limits, A/B test assignments, kill switches) and getting it wrong can take down your entire fleet. The system must support hot-reload (change configs without restarting services), feature flags with gradual rollouts, environment hierarchies (dev/staging/prod), a full audit trail, and safe rollback. Netflix's Archaius, Google's Borg config, and LaunchDarkly all solve variants of this problem. Interviewers love this question because it touches distributed systems fundamentals (consistency vs. availability, push vs. pull), product thinking (feature flags, rollout strategies), and operational excellence (audit trails, rollback).

Premium Access
Sign in

Design Data Pipeline (ETL/ELT System)

Design a scalable data pipeline platform like Apache Airflow + Fivetran + dbt — an end-to-end system that extracts data from thousands of heterogeneous sources (databases, APIs, event streams), loads it into a central data lake or warehouse, transforms it into analytics-ready tables, and orchestrates the entire workflow as directed acyclic graphs (DAGs). The system must handle 10,000+ concurrent pipelines processing 1 PB/day, guarantee exactly-once semantics for critical financial data, support schema evolution without breaking downstream consumers, enforce data quality gates before publishing datasets, and provide full column-level lineage from source to dashboard. This is the backbone of every modern data-driven company — and a favorite interview question at companies building data infrastructure.

Premium Access
Sign in

Design a Distributed Database (Spanner/CockroachDB)

Design a globally distributed SQL database like Google Spanner or CockroachDB. The system must provide full SQL semantics — joins, indexes, foreign keys, ACID transactions — across a cluster that spans multiple datacenters and continents. Unlike traditional distributed key-value stores that sacrifice consistency for availability, this system chooses strong consistency (CP in CAP terms): every read sees the result of the most recent committed write, even across regions. The core challenge is achieving external consistency (the strongest form of consistency — stronger than linearizability) while maintaining low-latency reads and writes across a globally distributed cluster. You will design a Raft-based consensus layer for replication, a two-phase commit protocol for cross-range transactions, a TrueTime or Hybrid Logical Clock mechanism for global ordering, range-based sharding for data distribution, and a distributed SQL query engine that pushes computation close to the data.

Premium Access
Sign in

Design a Distributed Lock Service

Design a distributed lock service that provides mutual exclusion across thousands of distributed nodes at 1M lock acquisitions per second with sub-5ms P99 latency. This is a foundational infrastructure problem that appears in every large-scale distributed system — from preventing double-charging in payment systems to ensuring exactly-once processing in data pipelines. The core challenge is deceptively simple: how do you guarantee that exactly one process holds a lock at any given time, even when networks partition, clocks drift, processes crash mid-operation, and GC pauses freeze threads for hundreds of milliseconds? Simple Redis SETNX fails under partition. Redlock is controversial. ZooKeeper works but is slow. This question separates engineers who understand distributed consensus from those who think locking is just a SETNX command.

Premium Access
Sign in

Design Live Streaming Platform

Design a large-scale live streaming platform like Twitch or YouTube Live. This is one of the hardest system design problems because it spans every layer of the stack: real-time media ingest from hundreds of thousands of concurrent streamers via RTMP/SRT, a massive transcoding farm that produces adaptive bitrate (ABR) renditions in real time, a CDN edge network delivering HLS/DASH segments to tens of millions of concurrent viewers with sub-5-second latency, a chat system that must fan out messages to rooms with 100K+ participants at sub-200ms delivery, and a DVR/rewind system that lets viewers seek backward in a live stream without disrupting the live edge. The core tension is between latency and scale: WebRTC gives sub-second latency but does not scale past thousands; HLS scales to billions but adds 15-30 seconds of delay. Modern solutions like Low-Latency HLS (LL-HLS) and WebTransport sit in the sweet spot.

Premium Access
Sign in

Design a Service Registry & Discovery System

Design a service registry and discovery system that tracks 50K service instances across multiple datacenters, handles 10M discovery lookups per second with sub-5ms latency, and self-heals when instances crash or become unhealthy. In a microservices architecture, Service A needs to find healthy instances of Service B to send requests to — but instances are ephemeral (containers start and stop, auto-scaling adds and removes nodes, deployments roll through). Hard-coding IP addresses is impossible. A service registry is the phone book of microservices: services register themselves on startup, deregister on shutdown, and other services look them up at runtime. Netflix Eureka, HashiCorp Consul, and AWS Cloud Map are production implementations. This interview question tests your understanding of registration protocols, health checking strategies (client-side vs. server-side heartbeats), discovery patterns (client-side vs. server-side vs. DNS-based), consistency trade-offs (AP vs. CP registries), and the critical failure modes that can cascade a registry outage into a fleet-wide meltdown.

Premium Access
Sign in

Design Recommendation System

Design a large-scale recommendation system like Netflix's movie suggestions, Spotify's Discover Weekly, or TikTok's For You Page. The system must serve personalized recommendations to 500M+ users across 100M+ items with sub-200ms latency. This problem tests your ability to reason about candidate generation and ranking pipelines, feature engineering with online/offline stores, model serving infrastructure, cold-start strategies, and the exploration-exploitation tradeoff — the core challenges behind every modern recommendation engine.

Premium Access
Sign in

Design a Time-Series Database

Design a time-series database (TSDB) optimized for storing, compressing, and querying timestamped metric data — the kind generated by infrastructure monitoring (CPU usage, request latency), IoT sensors (temperature, pressure), financial markets (stock prices, trade volumes), and application telemetry (events, counters). Unlike general-purpose databases, a TSDB must handle extreme write throughput (millions of data points per second), store data efficiently using time-aware compression (10-20x compression ratios), support fast time-range queries ('give me the average CPU across 500 servers for the last 24 hours'), and manage data lifecycle through automatic retention policies and downsampling. The core challenge is designing a storage engine that is simultaneously write-optimized (append-only time-series writes are sequential) and read-optimized (time-range queries must scan compressed columnar data efficiently), while handling the 'cardinality explosion' problem: millions of unique metric series (host x metric x tag combinations) that stress both memory and indexing.

Premium Access
Sign in

Design a Data Warehouse (Snowflake/BigQuery)

Design a cloud-native data warehouse that can store petabytes of structured data and execute complex analytical queries (joins across billion-row tables, multi-dimensional aggregations, window functions) in seconds to minutes. Unlike OLTP databases optimized for single-row reads and writes, a data warehouse is optimized for scanning massive datasets — reading millions of rows but only a few columns at a time. The key innovation is the Snowflake architecture: **compute-storage separation**, where data is stored in cheap, durable cloud object storage (S3/GCS) and computation is provided by elastic, independently scalable virtual warehouse clusters. This means you can run 10 concurrent analytical workloads on the same dataset without them interfering with each other, scale compute up for a heavy query and back down to zero when idle, and pay only for the compute you actually use. You will design a columnar storage layer, an MPP (Massively Parallel Processing) query engine, an ETL/ELT ingestion pipeline, and a multi-tenant resource management system.

Premium Access
Sign in

Design Real-Time Stream Processing System

Design a distributed real-time stream processing system like Apache Flink, Kafka Streams, or Apache Storm — a platform that continuously processes millions of events per second with sub-second latency, performs stateful aggregations over time windows, guarantees exactly-once processing semantics, and handles late-arriving data gracefully using watermarks. The system must support tumbling, sliding, and session windows; maintain distributed state across processing nodes; checkpoint state for fault tolerance; and handle backpressure when downstream systems are slow. This is the engine behind Uber's real-time pricing, Netflix's per-title viewing analytics, LinkedIn's real-time activity feed, and every fraud detection system processing credit card transactions. It is one of the most technically demanding system design questions because it requires deep understanding of distributed systems, time semantics, and fault tolerance under continuous processing.

Premium Access
Sign in

Design Gaming Platform

Design the backend infrastructure for a competitive online multiplayer game like League of Legends, Fortnite, Valorant, or Overwatch. This is one of the most technically demanding system design problems because it combines multiple hard sub-problems: a matchmaking system that must find balanced matches for millions of concurrent players in under 30 seconds, a tick-based game server architecture running at 60-128Hz where every millisecond of latency affects gameplay, an authoritative server model where the server is the single source of truth to prevent cheating, lag compensation techniques (client-side prediction, server reconciliation, entity interpolation) that make the game feel responsive despite 20-100ms network latency, a global leaderboard serving real-time rankings across millions of players, an inventory/economy system managing billions of virtual item transactions, and an anti-cheat system detecting cheaters without degrading the experience for legitimate players. The core tension: the game must feel instantaneous to every player while the server enforces a consistent, cheat-proof world state across all participants.

Premium Access
Sign in

Design Analytics Platform (Mixpanel / Amplitude)

Design a product analytics platform like Mixpanel or Amplitude. The system ingests billions of user behavior events per day (page views, button clicks, purchases) and enables product teams to query this data in real time across arbitrary dimensions — funnels ('what percentage of users who viewed a product also purchased it?'), retention ('what percentage of users who signed up in January are still active in March?'), cohort analysis ('how do users who completed onboarding compare to those who skipped it?'), and segmentation ('break down purchases by country, device, and plan type'). The core challenge is making these complex analytical queries fast (sub-10-second response) across 100B+ events/day while supporting multi-tenant isolation and flexible schema evolution.

Premium Access
Sign in

Design Search System (Internal / App Search)

Design an internal search system that powers product search for an e-commerce platform, listing search for a marketplace, or document search for a SaaS application. The system must support full-text search with typo tolerance, faceted filtering (by category, price range, location), relevance tuning (boosting newer or more popular items), multi-tenant index isolation, and autocomplete — all at 50K queries/sec with sub-100ms P95 latency. This is the kind of search that Algolia, Elasticsearch, and Typesense power for thousands of applications.

Premium Access
Sign in