Top 50 System Design Interview Questions in 2026

Three things changed in system design interviews this year:

1. AI infrastructure is now standard. Expect at least one question on serving LLMs, building RAG systems, or designing agent platforms.
2. Cost is back. Post-ZIRP, interviewers want to see you reason about $/request and not just throughput.
3. Multi-region is the default. The "single region for now" answer that got you hired in 2020 won't fly anymore.

Here are the 50 questions that came up in 2026 interviews, sorted by category. For each one, the patterns you should name without prompting.

Classic Web-Scale (1-10)

1. Design a URL shortener (TinyURL)

Patterns to name: base62 encoding, distributed counters, key collision handling, write-through cache, CDN for redirects.

The trap: most candidates over-engineer. The hard part is the read path - 99% of traffic is GETs. Get the hot key caching strategy right.

2. Design Twitter / X timeline

Patterns: fan-out on write vs fan-out on read, hybrid for celebrities, materialized timelines in Redis, push-pull model.

The follow-up question is always "how do you handle a user with 100M followers?" Answer: pull, not push.

3. Design Instagram

Similar to Twitter but image-heavy. Patterns: CDN, image processing pipeline (resize/compress on upload), object storage tiers, lazy thumbnail generation.

4. Design WhatsApp / messaging app

Patterns: persistent connections (WebSocket/MQTT), per-user message queues, end-to-end encryption (mention Signal protocol), delivery receipts state machine, presence service.

5. Design YouTube

Patterns: chunked upload, video transcoding pipeline, ABR (adaptive bitrate streaming), CDN with regional edges, recommendation service.

6. Design Dropbox / Google Drive

Patterns: content-defined chunking, deduplication via content hashes, metadata service, sync protocol, conflict resolution.

7. Design Uber / Lyft

Patterns: geo-indexing (S2/H3 cells), supply-demand matching, surge pricing, location streaming, ETA service.

The interesting subproblem: matching efficiency. Not just nearest driver - you optimize a global assignment.

8. Design Netflix

Patterns: content delivery (Open Connect / CDN), encoding ladders, CDN cache hierarchy, recommendation engine, A/B testing infrastructure.

9. Design Airbnb / booking system

Patterns: distributed locking on availability, two-phase booking, payment integration, search (geo + filters), pricing engine.

10. Design a search engine

Patterns: crawler, inverted index, sharded index by document ID, ranking pipeline, query understanding, caching popular queries.

Data and Storage (11-20)

11. Design a key-value store (Dynamo/Cassandra)

Patterns: consistent hashing, virtual nodes, replication factor, quorum reads/writes, gossip for membership, anti-entropy for repair.

12. Design a distributed cache

Patterns: consistent hashing for placement, TTLs, eviction (LRU/LFU), cache stampede prevention (singleflight, request coalescing), warming strategy.

13. Design a message queue (Kafka)

Patterns: topics partitioned across brokers, leader-follower replication, consumer groups, offset tracking, log compaction.

14. Design a distributed file system

Patterns: GFS/HDFS architecture (namenode + datanodes), block replication, write pipeline, master metadata.

15. Design a time-series database

Patterns: time-partitioned shards, columnar storage, downsampling/rollups, retention policies, push-down predicates.

16. Design a column-store / OLAP database

Patterns: columnar storage, vectorized execution, query planner, partition pruning, materialized views.

17. Design a transactional database

Patterns: ACID, MVCC, WAL, two-phase locking, isolation levels, replication for HA.

18. Design a search index for product catalogs

Patterns: Elasticsearch/OpenSearch architecture, sharding by tenant, inverted indexes, faceted search, suggestion APIs.

19. Design a recommendation system

Patterns: collaborative filtering, content-based, embeddings + ANN, candidate generation + ranking, real-time vs batch updates.

20. Design a graph database

Patterns: native graph storage, index-free adjacency, traversal API, sharding (hard problem - mention this), property graph model.

Real-Time and Streaming (21-28)

21. Design a real-time analytics pipeline

Patterns: Kafka ingest, stream processor (Flink/Spark Streaming), windowing, exactly-once semantics, output to OLAP store.

22. Design a real-time leaderboard

Patterns: Redis sorted sets for hot leaderboards, rank approximation for huge user counts, periodic snapshots, regional vs global leaderboards.

23. Design a notification system

Patterns: topic-based fan-out, per-user inbox, push (APNs/FCM) + in-app, batching/throttling, user preferences, idempotency.

24. Design a multiplayer game backend

Patterns: sticky sessions on game servers, state authority on server, client prediction + rollback, region-based matchmaking, chat as separate service.

25. Design a video conferencing system (Zoom)

Patterns: SFU (selective forwarding unit) vs MCU, WebRTC, regional media servers, simulcast, end-to-end encryption.

26. Design a live streaming platform (Twitch)

Patterns: RTMP ingest, transcoding pipeline, HLS/DASH delivery, edge CDN, chat as a separate scaling problem.

27. Design a real-time collaboration tool (Google Docs)

Patterns: OT (operational transform) or CRDT, document service, presence service, conflict resolution, offline support.

28. Design a stock trading system

Patterns: order book in memory, matching engine, FIX protocol gateway, market data fan-out, risk checks pre-trade.

The follow-up: latency budget. Microseconds matter. Mention kernel bypass (DPDK), co-located servers, FPGA for the hot path.

AI and ML Infrastructure (29-38)

29. Design an LLM serving platform

Patterns: model sharding (tensor parallel, pipeline parallel), continuous batching, KV cache management, request queuing, speculative decoding, multi-tenant isolation.

This is the question of 2026. If you can't answer it, you're not ready for AI infra interviews.

30. Design a RAG (retrieval-augmented generation) system

Patterns: document ingestion pipeline, chunking strategy, embedding service, vector store + ANN, hybrid search (BM25 + semantic), reranker, prompt assembly with context window management.

31. Design a real-time embedding service

Patterns: batched inference, caching by content hash, model versioning, A/B testing, GPU utilization tracking.

32. Design an agent platform

Patterns: tool registry, sandboxed execution environment, conversation memory store, observability/traces, parallel execution, cost tracking per agent.

33. Design a model training platform

Patterns: distributed training (DDP, FSDP), checkpoint management, dataset versioning, experiment tracking, GPU scheduling, auto-resume on preemption.

34. Design a feature store

Patterns: offline (training) + online (serving) consistency, point-in-time correctness, feature transformations, materialization, registry.

35. Design a model registry and deployment system

Patterns: versioned model artifacts, metadata, canary rollouts, shadow traffic, automatic rollback, model lineage.

36. Design an evaluation system for LLM applications

Patterns: golden datasets, LLM-as-judge, human eval routing, regression detection, A/B traffic splitting, eval result store.

37. Design a fine-tuning service

Patterns: dataset upload + validation, multi-tenant GPU pools, base model registry, fine-tuning job queue, evaluation on test set, model promotion.

38. Design a vector database

Patterns: ANN algorithms (HNSW, IVF, ScaNN), index sharding, hybrid search, metadata filtering, replication, real-time indexing vs batch.

Infrastructure and Platform (39-46)

39. Design a monitoring system (Prometheus / Datadog)

Patterns: pull-based scraping, time-series storage, label-based queries, alerting rules, downsampling, federation across regions.

40. Design a logging system (Splunk / ELK)

Patterns: log shippers, partitioned indices, search across shards, retention tiers, structured logging, sampling for high-volume sources.

41. Design a distributed tracing system (Jaeger)

Patterns: trace context propagation (W3C TraceContext), spans, sampling decisions at edge, trace storage with TTL, query API.

42. Design a CI/CD platform

Patterns: event-driven workflow engine, isolated build environments (containers), artifact storage, secret management, parallel test execution, deploy gates.

43. Design a feature flag system

Patterns: rule evaluation at edge, real-time updates via streaming or polling, audit log, A/B test integration, rollout percentages.

44. Design a rate limiter

Patterns: token bucket vs leaky bucket, sliding window vs fixed window, distributed counter (Redis), per-user/per-endpoint policies.

45. Design an API gateway

Patterns: request routing, auth/authz, rate limiting, request/response transformation, service discovery integration, circuit breakers.

46. Design a config service (etcd / Consul)

Patterns: Raft consensus, watch API, lease-based locks, key namespacing, TLS auth.

Modern Niche Questions (47-50)

47. Design a payments platform (Stripe)

Patterns: idempotency keys, distributed sagas for multi-step flows, ledger as source of truth, PCI scope minimization, webhook delivery with retry, event sourcing for audit.

48. Design a multi-region active-active architecture

Patterns: CRDT or per-region primary with async replication, conflict resolution policies, traffic routing (Anycast/GeoDNS), regional failover, data residency compliance.

49. Design a multi-tenant SaaS platform

Patterns: isolation strategies (shared vs siloed vs hybrid), per-tenant quotas, tenant routing, encryption per tenant, billing integration, tenant lifecycle.

50. Design a serverless platform (Lambda / Cloud Run)

Patterns: cold start mitigation (snapshotting, pre-warming), function versioning, scaling policies, isolation (Firecracker/gVisor), event source bindings, observability.

How to Approach Any System Design Question

Same skeleton, every time. Drift from this and you'll lose points.

1. Clarify requirements (3-5 minutes). Functional, non-functional. Read/write ratio. Latency targets. SLA. Scale of users and data. Don't skip this.
2. Estimate scale. QPS, storage, bandwidth. Show the math.
3. API design. What does the request look like? What does the response look like?
4. High-level architecture. Boxes and arrows. Name your components.
5. Deep dive on the hardest 1-2 components. Pick the parts the interviewer cares about.
6. Trade-offs and bottlenecks. What breaks first as you scale? What's the single point of failure?
7. Evolution. What does v2 look like in 12 months? Multi-region? Different data store?

The candidates who fail aren't the ones who don't know enough. They're the ones who don't structure their answer.

What Senior+ Interviews Test Differently

If you're interviewing for staff or principal:

• Cost reasoning. $/request, $/user, $/QPS. Not just "scales horizontally."
• Failure modes. What happens when a region goes down mid-write? When the cache evaporates?
• Migration strategy. How do you get from the current architecture to the new one without downtime?
• Organizational fit. Who owns each component? How does the system change as the team grows from 5 to 50?
• Trade-offs. Be willing to say "we'd choose simplicity over the optimal solution here because the team can't operate the optimal one."

The signal at senior+ is not technical depth alone - it's judgment.

Final Thoughts

System design interviews reward pattern recognition. The 50 questions above cover ~80% of the design space. If you can comfortably whiteboard 10 of these without prep, you're in good shape for most interviews. If you can do 30, you're at staff level.

The most underrated prep technique: read post-mortems. Every published outage report from a major company is a free system design lesson with the trade-offs already evaluated under fire.

Want to practice these with structured mock interviews and graded feedback? gitGood.dev has system design tracks for every question above, plus weekly live mocks with senior engineers.