Top 15 System Design Interview Questions in 2026#

System design interviews test your ability to build scalable, reliable systems. Here are the 15 most commonly asked questions — with the key components, trade-offs, and architecture patterns you need to know.

For each question, we include the reference architecture you can generate instantly on Codelit.io.

Easy (15-20 minutes)#

1. Design a URL Shortener (bit.ly)#

Key concepts: Hashing, database design, caching, redirect handling

Components: API Gateway, URL Service, PostgreSQL, Redis Cache, Analytics Queue

Trade-offs:

• Hash collision handling: random vs sequential vs base62 encoding
• 301 (permanent) vs 302 (temporary) redirects affect analytics accuracy
• Cache-aside pattern for hot URLs (99% reads)

Generate this architecture →

2. Design a Rate Limiter#

Key concepts: Token bucket, sliding window, distributed rate limiting

Components: API Gateway, Rate Limiter (Redis), Configuration Service

Trade-offs:

• Token bucket vs sliding window vs fixed window algorithms
• Centralized (Redis) vs distributed (local + sync) rate limiting
• Hard vs soft limits, graceful degradation

3. Design a Key-Value Store#

Key concepts: Consistent hashing, replication, CAP theorem

Components: Coordinator, Storage Nodes (ring), Gossip Protocol, Replication Manager

Trade-offs:

• Consistency vs availability (CP vs AP)
• Replication factor: more replicas = more durability, higher write latency
• Conflict resolution: last-write-wins vs vector clocks

Medium (25-30 minutes)#

4. Design a Chat Application (Slack/WhatsApp)#

Key concepts: WebSocket, message ordering, presence, fan-out

Components: WebSocket Gateway, Chat Service, Presence Service, Message Store, Notification Service, Kafka

Trade-offs:

• WebSocket for real-time, but need fallback for reconnection
• Message ordering: per-channel sequence numbers
• Group chat fan-out: pre-compute member lists vs query on send

Generate this architecture →

5. Design a Social Media Feed (Twitter/X)#

Key concepts: Fan-out, timeline caching, celebrity problem

Components: Tweet Service, Timeline Service, Fan-out Service, Follow Graph, Redis Cache, Kafka

Trade-offs:

• Fan-out on write (fast reads, slow writes) vs fan-out on read (slow reads, fast writes)
• Hybrid approach: fan-out on write for normal users, on read for celebrities (100M+ followers)
• Timeline cache size vs freshness

6. Design a Ride-Sharing Service (Uber)#

Key concepts: Geospatial indexing, real-time matching, surge pricing

Components: API Gateway, Matching Service, Location Service (Redis Geo), Trip Service, Payment Service, Kafka

Trade-offs:

• Geohash vs QuadTree for spatial indexing
• Matching algorithm: nearest driver vs optimal (consider rating, ETA)
• Surge pricing transparency vs revenue optimization

Generate this architecture →

7. Design a Video Streaming Platform (Netflix)#

Key concepts: Adaptive bitrate, transcoding, CDN, recommendations

Components: CDN, Transcoding Workers, S3, Content Service, Recommendation Engine, Kafka

Trade-offs:

• Pre-transcode all qualities vs transcode on demand
• CDN cache hit ratio optimization (predictive pre-warming)
• Recommendation: collaborative filtering vs content-based vs hybrid

8. Design an E-Commerce Platform (Amazon)#

Key concepts: Inventory management, cart consistency, payment idempotency

Components: Product Catalog, Cart Service, Order Service, Payment Service, Inventory Service, Search (Elasticsearch)

Trade-offs:

• Inventory: pessimistic locking (accurate) vs optimistic (faster, may oversell)
• Cart: session-based vs persistent (logged-in users)
• Two-phase commit for order → payment → inventory

Hard (30-40 minutes)#

9. Design a Payment Processing System (Stripe)#

Key concepts: PCI compliance, idempotency, ledger, fraud detection

Components: API Gateway (PCI zone), Payment Orchestrator, Card Vault (HSM), Ledger, Fraud Detection, Webhook Service

Trade-offs:

• Synchronous authorization vs async capture
• Double-entry ledger for financial accuracy
• Fraud rules: rule-based (fast) vs ML (accurate, slower)

Generate this architecture →

10. Design a Distributed File Storage (Dropbox/Google Drive)#

Key concepts: Chunked uploads, delta sync, conflict resolution

Components: Metadata Service, Chunk Storage (S3), Sync Service, Notification Service, Conflict Resolver

Trade-offs:

• Full sync vs delta sync (only changed bytes)
• Conflict resolution: last-write-wins vs merge vs user prompt
• Client-side dedup: hash before upload to save bandwidth

11. Design a Search Engine (Google)#

Key concepts: Web crawling, inverted index, PageRank, query processing

Components: Web Crawler, URL Frontier, Parser, Inverted Index (sharded), Ranking Service, Query Service, CDN

Trade-offs:

• Crawl frequency vs freshness vs politeness
• Index partitioning: by document vs by term
• Ranking: PageRank + ML relevance + freshness signals

12. Design a Notification System#

Key concepts: Multi-channel delivery, rate limiting, priority queuing

Components: API Gateway, Notification Service, Template Engine, Channel Dispatchers (email, push, SMS, in-app), Preference Service, Kafka

Trade-offs:

• Push vs pull for in-app notifications
• Delivery guarantees: at-least-once vs exactly-once
• Rate limiting per user per channel to prevent spam

13. Design a Distributed Cache (Redis)#

Key concepts: Consistent hashing, eviction policies, replication

Components: Cache Proxy, Cache Nodes (ring), Gossip Protocol, Monitoring

Trade-offs:

• LRU vs LFU vs TTL-based eviction
• Cache-aside vs write-through vs write-behind patterns
• Single-leader replication vs multi-leader

14. Design a Metrics/Monitoring System (Datadog)#

Key concepts: Time-series data, aggregation, alerting, dashboards

Components: Agent, Ingestion Service, Time-Series DB, Aggregation Engine, Alert Manager, Dashboard (Grafana)

Trade-offs:

• Resolution: per-second (expensive) vs per-minute (cheaper, less granular)
• Push (agent sends) vs pull (server scrapes) collection
• Alert evaluation: per-metric vs composite rules

15. Design a Content Delivery Network (CDN)#

Key concepts: Edge caching, cache invalidation, origin shielding

Components: Edge PoPs, Origin Shield, Origin Server, DNS (GeoDNS), Cache Manager, Analytics

Trade-offs:

• Push (pre-warm) vs pull (on-demand cache fill)
• Cache invalidation: TTL vs purge API vs versioned URLs
• Multi-tier caching: edge → regional → origin shield → origin

How to Practice#

1. Set a timer — 30 minutes for medium, 40 for hard
2. Start with requirements — Clarify functional and non-functional requirements
3. High-level design first — Major components and data flow
4. Deep dive — Pick 1-2 components to detail (database schema, API design)
5. Address trade-offs — Show you understand the alternatives

Practice with AI feedback: The Architecture Coach on Codelit.io has 8 guided challenges with hints and reference architectures. Or describe any system and get an interactive diagram to study.

Resources#

• 100 Product Specs — Uber, Netflix, Stripe, and more with full PRD framework
• 90+ Architecture Templates — Interactive diagrams to explore
• Architecture Coach — Guided practice with hints

---

Practice system design at codelit.io — generate interactive architecture diagrams for any system in seconds.