100+ System Design Interview Questions

Design a URL Shortener (TinyURL)

Design a high-scale URL shortening service like TinyURL or Bitly. The system must support creating short 7-character aliases, high-concurrency 301/302 redirects with low latency (<10ms), custom alias collision handling, and URL expiration cleanup.

Design a Pastebin Text Sharing Service

Design a text storage and sharing platform where users can paste plain text or code snippets, generate a shareable link, set custom expiration dates, and configure access passwords. Prioritize high read-to-write ratio and cost-effective object storage.

Design an API Gateway & Dynamic Reverse Proxy

Design a high-throughput, sub-5ms latency API Gateway. The system must handle centralized authentication/JWT validation, distributed token-bucket rate limiting, dynamic upstream routing with service discovery, SSL termination, and request transformation.

Design a Distributed Rate Limiter

Design a multi-tiered distributed rate limiter to protect backend services from abuse and DDoS. Compare Token Bucket, Leaky Bucket, and Sliding Window algorithms with Redis cluster synchronization, race condition prevention (Lua scripts), and client error handling (HTTP 429).

Design a Distributed Feature Flag & Config Service

Design a real-time feature flag and dynamic configuration management platform. The system should support granular user targeting (percentage rollouts, user attributes, geographic clusters), zero-downtime rule updates, client-side caching with streaming pushes, and audit logging.

Design a High-Reliability Webhook Delivery Engine

Design a webhook delivery system that guarantees at-least-once delivery of event payloads to external third-party endpoints. Support exponential backoff retry schedules, cryptographic HMAC signature generation, dead letter queueing, and endpoint health circuit breaking.

Design a Short URL Platform with Real-Time Analytics

Design an analytics layer on top of a URL shortener that aggregates click counts, geographical location, referrer domains, device types, and browser agents in real time without increasing redirection latency on the critical read path.

Design a Distributed Circuit Breaker & Service Mesh

Design an automated circuit breaking and resilience proxy service for microservice communications. Support rolling error rate thresholds, automatic state transitions (Closed -> Open -> Half-Open), synthetic health probes, fallback degradations, and distributed telemetry propagation.

Distributed Storage & Caching(10 questions)

Design a Distributed In-Memory Cache (Redis/Memcached)

Design a distributed in-memory cache supporting sub-millisecond GET and SET operations, LRU/LFU eviction policies, consistent hashing with virtual nodes for partitioning, replication for high availability, and strategies to prevent cache stampede, penetration, and avalanche.

Design a Distributed Key-Value Store (DynamoDB / Cassandra)

Design a highly available, horizontally partitioned distributed key-value store based on the Amazon Dynamo paper. Implement consistent hashing, tunable consistency (N, R, W quorum), vector clocks for conflict resolution, gossip protocol for failure detection, and hinted handoff.

Design a Cloud Object Storage Service (AWS S3)

Design a petabyte-scale blob and object storage system like AWS S3. Address immutable binary chunking, metadata vs raw payload separation, multipart parallel uploads, erasure coding for 99.999999999% durability, geographic replication, and lifecycle tiering.

Design a Distributed Lock Manager (Redlock / Chubby)

Design a robust distributed lock manager for synchronizing access to shared resources across hundreds of nodes. Address clock drift, fencing tokens, network partitions, TTL renewal / heartbeat watchdogs, and fault-tolerant leader election.

Design a Distributed File System (GFS / HDFS)

Design a distributed file system optimized for append-heavy sequential reads and writes of massive files (multi-gigabyte to terabyte). Model the Master/NameNode metadata catalog, chunk server replica placement, heartbeats, and client direct read streaming.

Design a Time-Series Database (TSDB for Metrics & IoT)

Design a specialized time-series storage engine for ingesting millions of timestamped metric points per second. Implement Gorilla-style delta-of-delta time and XOR floating-point compression, downsampling rollups, out-of-order ingestion, and retention tiering.

Design an LSM-Tree Based Storage Engine (RocksDB)

Design an embedded write-optimized storage engine utilizing Log-Structured Merge (LSM) trees. Detail the Write-Ahead Log (WAL), in-memory MemTable (SkipList), immutable SSTables, Leveled vs Size-Tiered Compaction, and Bloom Filters for point lookups.

Design a Scalable Distributed Counter (Views & Likes)

Design a high-frequency counting system capable of recording billions of video views, upvotes, and likes without database row locking bottlenecks. Implement sharded counters, in-memory write aggregation buffers, and eventual consistency flushes.

Design a Distributed Bloom Filter Membership Service

Design a centralized, highly optimized probabilistic membership query service (Bloom Filter / Cuckoo Filter) to determine whether a malicious URL, username, or cached key exists before hitting expensive disk or database layers.

Design a Consistent Hashing Ring & Distributed Hash Table

Design a consistent hashing ring service for dynamic distributed cluster routing. Implement virtual node allocation for uniform load distribution, node addition and removal rebalancing, replication across subsequent clockwise nodes, and failure detection.

Messaging, Streams & Event-Driven(8 questions)

Design a Distributed Message Queue (Apache Kafka / RabbitMQ)

Design a distributed streaming commit log capable of millions of writes per second with strict ordering guarantees within partitions. Cover consumer groups with offset commits, zero-copy reads (sendfile), log segment compaction, and broker replication with ISR (In-Sync Replicas).

Design a Scalable Notification System (Push, SMS, Email)

Design a notification platform capable of dispatching billions of push notifications (APNs/FCM), SMS (Twilio), and transactional emails per day. Cover priority queues, deduplication, rate limits, user opt-out preferences, and third-party gateway failover.

Design a Distributed Job & Task Scheduler

Design a distributed asynchronous job scheduler that executes one-time and recurring cron jobs across worker pools. Ensure at-least-once execution, worker heartbeats, task dependency DAG resolution, job retry policies, and graceful cancellation.

Design a Scalable Pub/Sub Event Broker

Design a multi-tenant Publish-Subscribe messaging broker. Support topic creation, dynamic subscriber filtering (attribute-based and prefix routing), fan-out delivery, backpressure handling, and dead-letter message buffering.

Design an Exponential Backoff & Dead Letter Queue Pipeline

Design a message processing recovery pipeline with exponential backoff with full jitter, tiered delay queues, failure classification (transient vs permanent errors), manual inspection dashboards, and replay mechanisms for dead-letter messages.

Design an Event-Sourced Banking / Audit Ledger System

Design an immutable event-sourced financial ledger using Command Query Responsibility Segregation (CQRS). Model append-only event streams, snapshot generation for fast state reconstruction, optimistic concurrency versioning, and read projection materialization.

Design a Delayed / Timed Execution Task Queue

Design a high-precision delayed task queue where millions of events must trigger at exact future timestamps (e.g., 15-minute order cancellation, cart expiry). Compare Hierarchical Timing Wheels, Redis Sorted Sets (ZADD by timestamp), and bucketed delay partitions.

Design a Globally Distributed Cron Scheduling Service

Design an enterprise cron scheduling service that schedules millions of recurring crons across globally distributed clusters with millisecond trigger accuracy, leader election to prevent duplicate executions, and high-availability master failover.

Real-Time Communication(9 questions)

Design a Real-Time Chat Application (WhatsApp / Messenger)

Design a 1-on-1 and group messaging system capable of supporting 2 billion active users. Handle persistent WebSocket connection management, message sequencing/ordering, delivery acknowledgments (sent/delivered/read receipts), offline message synchronization, and end-to-end encryption key exchange.

Design a Real-Time Collaborative Document Editor (Google Docs)

Design a multi-user real-time rich text editor supporting concurrent typing with sub-100ms synchronization. Compare Operational Transformation (OT) and Conflict-free Replicated Data Types (CRDTs / Yjs), undo/redo history trees, cursor tracking, and offline edit reconciliation.

Design a Video Conferencing & Signaling Architecture (Zoom)

Design the infrastructure for large-scale group video calls. Model WebRTC signaling (SIP/SDP/WebSocket), NAT traversal (STUN/TURN), Selective Forwarding Units (SFU) vs Multipoint Control Units (MCU), adaptive bitrate switching (Simulcast/SVC), and recording pipelines.

Design a High-Scale User Presence Service (Discord / Slack)

Design a user presence platform that tracks when hundreds of millions of users are Online, Idle, Do Not Disturb, or Offline. Implement periodic client heartbeats, disconnect timeouts, and fan-out presence broadcasting to active friends and shared servers.

Design a Live Streaming Comments & Floating Reactions System

Design a live comment and heart/reaction engine for streams with over 1 million concurrent viewers. Implement client-side rate throttling, server-side message sampling, room-based WebSocket broadcast clusters with Redis Pub/Sub, and spam filtering.

Design a Multi-Tenant Customer Support Live Chat & Router

Design a live chat routing platform that routes incoming customer inquiries to available support agents based on skills, language, workload, and tier SLA. Include agent re-assignment on timeout, conversation history archiving, and automated typing indicators.

Design a Collaborative Vector Whiteboard (Miro / Excalidraw)

Design a real-time collaborative canvas where multiple users draw shapes, vectors, and sticky notes simultaneously. Address vector object spatial partitioning (R-Trees / QuadTrees), optimistic local rendering, state diff broadcasting via WebSockets, and snapshot backups.

Design a Selective Forwarding Unit (SFU) for Video Streams

Design a high-bandwidth SFU media server architecture that receives RTP video streams from publishers and routes appropriate resolution layers (Simulcast) to subscribers based on network downlink conditions and client viewport size.

Design an Ultra-Low Latency Live Sports Score Ticker

Design a push delivery system to deliver sub-second live match scores, ball-by-ball updates, and betting odds to tens of millions of mobile and web clients using Server-Sent Events (SSE) or WebSockets with edge caching.

Media, Streaming & Content Delivery(8 questions)

Design a Video Streaming Platform (YouTube / Netflix)

Design a video-on-demand platform serving hundreds of petabytes of video daily. Model video upload ingestion, adaptive bitrate chunking (HLS / DASH manifest generation), CDN edge caching topology, video resume playback state tracking, and recommendation feeds.

Design an Asynchronous Video Transcoding Pipeline

Design a distributed, fault-tolerant video processing pipeline that ingests raw 4K/8K video uploads, splits them into time-aligned segments, transcodes chunks in parallel across GPU/CPU worker fleets into multiple codecs (H.264, VP9, AV1), and merges playlists.

Design a Music Streaming & Audio Delivery Service (Spotify)

Design an audio streaming architecture supporting millions of concurrent music listeners. Address seamless gapless playback, encrypted audio chunk caching on mobile devices, offline synchronization, royalty tracking event streaming, and collaborative playlist sync.

Design a Global Content Delivery Network (CDN) & Edge Cache

Design a global CDN infrastructure with Points of Presence (PoPs) worldwide. Cover BGP Anycast DNS routing to the nearest edge server, HTTP caching hierarchy (Edge -> Shield -> Origin), cache purging mechanisms, byte-range requests for media, and SSL edge termination.

Design a Photo Sharing & Storage Platform (Instagram / Flickr)

Design a photo upload, filtering, and delivery system. Address client-side image compression, asynchronous thumbnail generation (multiple aspect ratios), blob storage indexing (Haystack/S3), metadata persistence in NoSQL/RDBMS, and CDN distribution.

Design an On-the-Fly Dynamic Image Resizing Proxy

Design a low-latency edge proxy that accepts URL query parameters (e.g. `/image.jpg?w=400&h=300&format=webp`), fetches the master image, performs fast in-memory transformation, compresses the output, and caches the processed variant at the edge.

Design a Podcast Hosting & RSS Feed Distribution System

Design a podcast publishing platform that validates MP3 audio uploads, generates compliant RSS 2.0 / iTunes XML feeds, handles traffic spikes when new episodes drop, and processes IAB-compliant download analytics.

Design an Audio Fingerprinting & Song Recognition App (Shazam)

Design an acoustic recognition system like Shazam. Model audio spectrogram generation, peak landmark extraction, combinatoric hashing of frequency-time pairs, and fast sub-second sub-fingerprint database lookups against millions of songs.

Social Networks & Community(9 questions)

Design a Social News Feed System (Facebook / X Timeline)

Design a high-scale social news feed. Detail the trade-offs between Fan-out-on-Write (push to follower inboxes) vs Fan-out-on-Read (pull on demand) for celebrity accounts, feed ranking algorithms, pagination with cursors, and Redis in-memory timeline caches.

Design an Ephemeral Stories Platform (Instagram Stories)

Design a 24-hour disappearing stories feature. Model media upload, unseen story ring indicators, viewer list recording with deduplication, fast sequential playback prefetching, and automatic TTL deletion from storage.

Design a Forum with Nested Comments & Karma (Reddit)

Design a community forum platform supporting sub-communities, post submissions, deeply nested comment trees (closure table / materialized path / nested set models), real-time upvote/downvote tallies, and hot/top post ranking algorithms.

Design a Social Graph Service (Connections & Recommendations)

Design a graph service capable of managing billions of friendship and follow edges. Support fast 1st-degree follower lookups, 2nd-degree mutual connection queries ('People You May Know'), bidirectional edge updates, and graph database vs adjacency list storage.

Design a Proximity Matching & Swiping Service (Tinder)

Design a dating app backend handling millions of swipes per second. Implement spatial indexing (GeoHash / S2 geometry) to find candidates within radius, fast swipe queueing, mutual match detection in Redis, and profile card deck recommendation generation.

Design a Real-Time Trending Hashtags Engine (Twitter / TikTok)

Design a streaming system to extract, count, and rank trending hashtags and keywords over tumbling and sliding time windows (e.g. past 1 hour, past 24 hours). Implement Count-Min Sketch for frequency estimation, decay algorithms, and spam suppression.

Design a Visual Bookmarking & Feed Platform (Pinterest)

Design a visual discovery engine allowing users to create boards, pin images, follow boards, and explore infinite scroll feeds. Model the bipartite graph between users, boards, and pins, image deduplication, and visual recommendation caching.

Design a Content Moderation & Abuse Reporting Queue

Design an automated and human-in-the-loop content moderation pipeline. Ingest user reports, pass content through automated AI safety classifiers, prioritize moderation review queues based on severity scores, and apply shadowbanning and takedown actions.

Design an Activity Timeline Engine with Hybrid Fan-Out

Design an activity timeline system for user actions (starred repo, commented on photo, changed job). Implement hybrid push/pull fan-out, timeline aggregation (collapsing 5 likes into one notification), and pagination strategies.

Search, Indexing & Crawling(8 questions)

Design a Distributed Web Crawler (Googlebot)

Design a scalable distributed web crawler that downloads billions of web pages per month. Address URL frontier queueing with politeness and priority tiers, DNS caching, duplicate URL elimination (Fingerprints/Bloom filters), HTML parsing, and robots.txt compliance.

Design a Real-Time Search Autocomplete / Typeahead System

Design a search autocomplete service providing top 5 suggestions with sub-20ms latency as a user types. Compare In-Memory Trie structures, inverted prefix tables, serialized trie nodes in Redis, offline phrase frequency aggregation with MapReduce, and personalization.

Design a Full-Text Search Engine with Inverted Index (Elastic)

Design a distributed full-text search engine. Cover document tokenization, stemming, stop-word removal, posting lists compression, BM25 / TF-IDF relevance scoring, distributed index sharding across primary and replica nodes, and incremental updates.

Design a Location-Based Proximity Search (Yelp / Google Places)

Design a proximity search service to find restaurants within a given radius. Compare 2D indexing techniques (QuadTree, Google S2 Geometry, and GeoHash strings), dynamic spatial subdivision in dense urban vs rural areas, and caching nearby query results.

Design a Distributed Log Ingestion & Search Engine (Datadog / ELK)

Design a log management system that ingests terabytes of semi-structured log streams per minute from thousands of servers, indexes fields in near real-time, provides regex search, and manages hot/warm/cold index retention cycles.

Design an E-Commerce Faceted Product Search Engine (Amazon)

Design a faceted product search engine supporting filtering by category, price ranges, brand, customer ratings, and dynamic facet count aggregations across millions of SKUs with sub-100ms response times.

Design a Reverse Image Search & Visual Similarity Engine

Design a reverse image search engine where users upload a photo to find visually identical or similar items. Cover deep feature embedding extraction (CNNs/Vision Transformers), vector quantization, and Approximate Nearest Neighbor (ANN) index searches.

Design an Enterprise Document Search & OCR Indexing Pipeline

Design an asynchronous document processing and search platform. Ingest PDFs, Word docs, and scanned images, run OCR text extraction and thumbnail rendering in worker pools, and index full text into an encrypted search database.

AI & Machine Learning Systems(10 questions)

Design an Enterprise Retrieval-Augmented Generation (RAG) System

Design a scalable RAG infrastructure for querying millions of company documents with LLMs. Model document chunking, embedding generation pipelines, vector database hybrid search (vector + keyword BM25), reranking models (Cohere Rerank), contextual prompt assembly, and token caching.

Design a Distributed LLM Inference Serving Platform (vLLM / Triton)

Design a low-latency, high-throughput LLM inference gateway. Address Continuous Batching, PagedAttention KV-Cache management across GPU VRAM, Tensor/Pipeline Parallelism across multiple GPU nodes, streaming token responses (SSE), and request scheduling.

Design a High-Scale Vector Database & ANN Indexer (Pinecone)

Design a distributed vector database capable of indexing billions of 1536-dimensional embeddings with sub-20ms search latency. Implement HNSW (Hierarchical Navigable Small World) graphs, Product Quantization (PQ), metadata filtering during traversal, and distributed shard partitioning.

Design an AI Agent Workflow Engine & Code Sandbox

Design a secure execution backend for autonomous AI agents. Support stateful multi-step agent reasoning loops, tool/function calling dispatchers, secure isolated ephemeral code execution sandboxes (gVisor/Firecracker microVMs), and resource quotas.

Design a Real-Time Machine Learning Feature Store (Feast / Tecton)

Design a centralized ML Feature Store that unifies feature definitions for model training (offline batch in S3/Snowflake) and live inference (online low-latency key-value store in Redis). Prevent training-serving skew and support point-in-time joins.

Design a Two-Tower Deep Neural Network Recommendation Pipeline

Design an end-to-end recommendation system serving personalized feeds to 100M+ users. Cover candidate generation (User Tower + Item Tower embedding dot products), heavy ranking (deep cross-network scoring features), business logic deduplication, and exploration/exploitation bands.

Design a Real-Time LLM Prompt & Response Guardrail Gateway

Design a high-speed security proxy intercepting user prompts and LLM completions. Implement prompt injection detection, PII masking/redaction, toxicity filtering, hallucination checking, and sub-30ms latency overhead.

Design a Scalable Generative AI Image Generation Service (Midjourney)

Design a job dispatch and queuing service for GPU-heavy diffusion model inference. Handle user priority tiers (Fast vs Relaxed mode), GPU autoscaling based on queue depth, intermediate progressive image step streams, and final image CDN caching.

Design a Real-Time ML Fraud Scoring Engine (Sub-50ms)

Design a sub-50ms fraud evaluation engine for payment transactions. Combine real-time streaming feature aggregation (e.g. transaction velocity over past 5 mins from Flink), graph network risk analysis (shared card/device ID), and synchronous ML model scoring.

Design a Distributed GPU Cluster ML Training Orchestrator

Design an orchestration and scheduling system for running distributed model training jobs across thousands of H100 GPUs. Manage spot instance preemption, all-reduce communication topology (NCCL over InfiniBand), distributed checkpointing, and automatic failure recovery.

E-Commerce, Logistics & Geospatial(9 questions)

Design a Ride-Hailing Matcher & Location Dispatch System (Uber)

Design a real-time ride matching and dispatch engine. Handle high-frequency driver GPS location updates (every 4s), spatial indexing (Uber H3 hexagonal grid), geospatial batch matching algorithms (supply vs demand in spatial cells), and ETA computation.

Design a Map Routing & Turn-by-Turn Navigation Engine

Design a map routing engine that computes the fastest route between two coordinates in under 100ms. Detail graph representation of road networks, contraction hierarchies, bidirectional A* search, real-time live traffic weight overlays, and tile rendering.

Design a Flash Sale & High-Concurrency Ticket Booking System

Design an inventory and checkout system for selling 10,000 concert tickets in 30 seconds to 1 million users. Prevent overselling with Redis atomic Lua decrements, virtual waiting rooms / tokenized queues, temporary inventory locks with expiration, and async payment settlement.

Design an On-Demand Food Delivery Platform (DoorDash)

Design the tripartite food delivery backend connecting customers, restaurants, and delivery drivers. Model the 3-state order lifecycle, driver dispatch heuristics (batching multiple orders from same restaurant), and live GPS courier tracking.

Design a Hotel & Short-Term Rental Reservation System (Airbnb)

Design a property booking and search platform. Handle calendar date range availability queries without double-booking race conditions, spatial property filtering, seasonal dynamic pricing, and escrow payment holds until check-in.

Design a Resilient Distributed Shopping Cart System (Amazon)

Design a highly available shopping cart service that never loses items even during cross-datacenter outages. Compare client-side cookie storage, persistent NoSQL session stores (DynamoDB), cart merging when anonymous users log in, and price fluctuation notifications.

Design a Real-Time Package Tracking & Milestone System (FedEx)

Design a package tracking platform receiving millions of barcode scan events from distribution hubs and sorting centers. Provide low-latency milestone timeline tracking for customers and predictive delivery date estimation.

Design a Smart IoT Parking Spot Finder & Reservation App

Design a smart parking reservation system receiving ultrasonic sensor telemetry from thousands of parking garages. Display live available spots on a map, lock reservations for 15 minutes, and handle automatic license plate gate opening.

Design a Real-Time Dynamic Surge Pricing Engine

Design a streaming pricing calculator that dynamically computes price multipliers based on real-time supply and demand imbalances within spatial hexagons (H3). Prevent price volatility and ensure multiplier consistency during user ride booking flows.

Fintech, Payments & Trading(9 questions)

Design a Payment Processing Gateway & Idempotent Charge Engine

Design a payment gateway handling billions of dollars in credit card transactions. Ensure strict idempotency keys to prevent double charging, PCI-DSS compliant card tokenization (vaults), Two-Phase Commit / Sagas with banking acquirers, and webhook settlement.

Design a Digital Wallet & Double-Entry Accounting Ledger (Venmo)

Design a digital wallet balance and ledger system. Enforce immutable double-entry bookkeeping (Debits == Credits), prevent negative balances under concurrent transfers using serializable transactions or deterministic state machine replication, and audit reconciliation.

Design an Ultra-Low Latency Stock Exchange & Matching Engine

Design an electronic order book (L2/L3 Limit Order Book) and matching engine with sub-10 microsecond latency. Implement Price-Time Priority (FIFO) matching, in-memory cache-line friendly data structures (B-Trees / Doubly Linked Lists), and deterministic order sequencing.

Design a Recurring Subscription Billing & Invoicing Engine

Design a multi-tiered subscription billing system handling prorations, trial periods, tiered usage-based metered billing, scheduled invoice generation at midnight in customer time zones, and automated smart dunning retries for failed credit cards.

Design an ATM Network & Core Banking Transaction Controller

Design the transaction processing software for an ATM network communicating with core banking mainframes over ISO 8583 protocols. Implement two-phase commit transaction rollbacks on hardware dispenser jams, PIN encryption (HSMs), and withdrawal limits.

Design a Multi-Chain Blockchain Indexer & Explorer (Etherscan)

Design a blockchain ingestion engine that connects to RPC nodes of multiple blockchains (Bitcoin, Ethereum), processes block reorganizations (re-orgs), decodes smart contract logs and ERC-20 token transfers, and powers fast address balance and transaction queries.

Design a Peer-to-Peer Instant Money Transfer App (Zelle / Cash App)

Design an instant P2P money transfer app. Cover user authentication, contact book matching, ACH bank pull vs instant debit card push settlements, transaction limit checks, and real-time push confirmations.

Design an Offline-First Point-of-Sale (POS) Terminal Sync System

Design an offline-first POS terminal for restaurants and retail. Allow transactions to be authorized and queued locally during internet outages, synchronize pending transactions upon reconnect, and resolve inventory conflict discrepancies.

Design a Dispute Resolution & Chargeback Handling Engine

Design a dispute management workflow engine. Ingest chargeback notices from card networks, notify merchants with evidence submission countdown timers, compile PDF evidence packages, and automatically debit/credit disputed funds.

Observability, Security & Dev Tools(9 questions)

Design a Distributed Tracing System (Jaeger / OpenTelemetry)

Design a distributed tracing infrastructure based on Google's Dapper paper. Model W3C Trace Context propagation across microservice RPC headers (Trace ID, Span ID), head-based vs tail-based trace sampling to control storage costs, and trace DAG reconstruction.

Design a Large-Scale Metrics Monitoring & Alerting Platform

Design a monitoring infrastructure collecting millions of system gauges, counters, and histograms per second. Implement pull (Prometheus scraper) vs push (StatsD/OpenTelemetry) models, promQL-style query evaluation, and deduplicated alerting with escalation policies.

Design a Secrets Management & Dynamic Key Rotation Vault

Design a zero-trust secrets management service like HashiCorp Vault. Model Shamir's Secret Sharing for master key unsealing, envelope encryption for secrets at rest, short-lived dynamic credentials for databases, and immutable audit access logging.

Design a Cloud CI/CD Build & Deployment Runner (GitHub Actions)

Design a distributed workflow orchestration engine that parses YAML pipeline definitions, provisions ephemeral isolated container/VM runners, streams real-time ANSI terminal build logs via WebSockets, and manages artifact build caches.

Design a Distributed WAF & DDoS Mitigation Edge (Cloudflare)

Design an edge network defense system capable of scrubbing multi-terabit volumetric DDoS attacks (SYN floods, UDP amplification) with eBPF/XDP packet filtering, executing WAF rules (OWASP Top 10) in under 1ms, and issuing cryptographic CAPTCHAs to suspicious traffic.

Design an Immutable Audit Logging & Compliance Ingestion Service

Design an enterprise audit logging pipeline capturing all API mutations across an organization. Guarantee write-once-read-many (WORM) tamper-evident storage using cryptographic Merkle trees, multi-region replication, and compliance retention policies (SOC2 / HIPAA).

Design a Distributed Git Repository Hosting Platform (GitHub)

Design the backend storage and compute architecture for hosting millions of Git repositories. Handle `git push` / `git fetch` over Smart HTTP and SSH, custom Git packfile storage on distributed block devices, pull request three-way merge generation, and webhook triggers.

Design a Distributed Package Registry & Artifact Storage (npm)

Design an artifact and package repository (npm/PyPI/Docker Hub). Ensure immutable package tarball uploads, fast global semantic version metadata queries, tarball CDN caching, malware scanning on publish, and scoped team access controls.

Design a High-Availability Anycast DNS & Traffic Director

Design an authoritative DNS service supporting Anycast routing, sub-millisecond UDP response times, latency-based geolocation routing, weighted round-robin records, and automated active health checks that dynamically pull unhealthy IP addresses from DNS pools.

Gaming, IoT & Edge Computing(4 questions)

Design a Multiplayer Game Matchmaking & Lobby Service

Design a matchmaking engine grouping players into balanced competitive matches (5v5) in under 30 seconds. Model MMR/Elo skill rating bands that expand over wait time, geographical latency constraints (ping to game servers), party queuing, and dedicated game server allocation.

Design a Real-Time Global Gaming Leaderboard (Top 10M Players)

Design a real-time leaderboard service displaying the top 100 global players and a player's immediate surrounding rank (±10 players) among 50 million active players. Compare Redis Sorted Sets (ZADD/ZRANK/ZREVRANGE), skip lists, and partitioned scoring buckets.

Design an IoT Connected Vehicle Fleet Telemetry Engine (Tesla)

Design a massive IoT telemetry ingestion hub receiving high-frequency sensor readings (speed, battery voltage, GPS, tire pressure) from 10 million vehicles via MQTT over cellular networks. Support live remote vehicle commands (unlock/honk) and over-the-air (OTA) firmware rolling updates.

Design a Cloud Gaming Ultra-Low Latency Streaming Platform

Design an interactive cloud gaming infrastructure streaming 4K 60FPS video with sub-20ms round-trip input latency. Model edge GPU container orchestration, hardware video encoding (NVENC/AV1 over WebRTC/RTP), UDP controller input streaming, and jitter buffer management.