System Design Visualized
Start free
Free lessons

System design, one concept at a time

The opening of every lesson is free to read, and the first chapters in full. Pro unlocks the rest. Open any lesson in the app to play its animation, solve its code challenge and take the quiz.

Concept of the weekAlgorithm 3: Fixed window counterSplit the timeline into fixed windows (e.g. one per minute) and give each a counter. Each request increments the counter. Once the counter hits the threshold, new requests are…Read the lesson →

Part 1 · Foundations

The vocabulary and the way of thinking. Start here.

1. Scale From Zero to Millions of Users

  1. Single server setup
  2. Separate the database (and pick SQL or NoSQL)
  3. Vertical vs horizontal scaling
  4. Load balancer
  5. Database replication
  6. Cache
  7. Content delivery network (CDN)
  8. Stateless web tier
  9. Multiple data centers
  10. Message queue
  11. Logging, metrics and automation
  12. Database scaling and sharding
  13. Millions of users and beyond

2. Back-of-the-Envelope Estimation

  1. Power of two
  2. Latency numbers every programmer should know
  3. Availability numbers
  4. Example: estimate Twitter QPS and storage
  5. Tips for estimating

3. A Framework for System Design Interviews

  1. What the interviewer is really looking for
  2. The 4-step process (and the clock)
  3. Step 1: Understand the problem and establish the design scope
  4. Step 2: Propose a high-level design and get buy-in
  5. Step 3: Design deep dive
  6. Step 4: Wrap up, plus dos and don'ts

Part 2 · Core concepts

Networking, databases, caching, reliability, distributed services, observability and security: the toolbox every design draws on.

C1. Networking & APIs

  1. The journey of one request
  2. HTTP essentials: methods, status codes, idempotency
  3. REST, GraphQL and gRPC
  4. Pagination: offset vs cursor
  5. API gateways
  6. Real-time: polling, long polling, SSE, WebSockets

C2. Databases in Depth

  1. Choosing a database by access pattern
  2. Indexes: why lookups are fast (and writes slower)
  3. Transactions and isolation
  4. Replication lag and read-your-writes
  5. Partitioning strategies

C3. Caching in Depth

  1. Caching strategies
  2. Eviction policies
  3. Invalidation and the stale-cache race
  4. Cache stampede (thundering herd)
  5. Where to cache, and how much it helps

C4. Reliability Patterns

  1. Timeouts and cascading failures
  2. Retries with exponential backoff and jitter
  3. Idempotency keys
  4. Circuit breakers
  5. Bulkheads, load shedding and graceful degradation

C5. Distributed Services

  1. Monolith, modular monolith, microservices
  2. Synchronous calls vs events
  3. Transactions across services: 2PC and sagas
  4. Delivery guarantees and idempotent consumers
  5. Leader election and consensus

C6. Observability & Security

  1. Logs, metrics and traces
  2. SLIs, SLOs, SLAs and error budgets
  3. Authentication: proving who you are
  4. Authorization: what you're allowed to do
  5. Abuse prevention and protecting data

Part 3 · Building blocks

Reusable pieces that appear inside almost every big system.

4. Design a Rate Limiter

  1. What a rate limiter does, and why
  2. Where to put the rate limiter
  3. Algorithm 1: Token bucket
  4. Algorithm 2: Leaking bucket
  5. Algorithm 3: Fixed window counter
  6. Algorithm 4: Sliding window log
  7. Algorithm 5: Sliding window counter
  8. High-level architecture and detailed design
  9. Rate limiting in a distributed environment
  10. Performance, monitoring and wrap up

5. Design Consistent Hashing

  1. The rehashing problem
  2. The hash ring
  3. Adding and removing servers
  4. Two problems, and virtual nodes
  5. Finding affected keys, and wrap up

6. Design a Key-Value Store

  1. Scope, and a single-server key-value store
  2. The CAP theorem
  3. Data partition and replication
  4. Consistency: quorum consensus (N, W, R)
  5. Inconsistency resolution: versioning and vector clocks
  6. Failure detection: the gossip protocol
  7. Handling failures: sloppy quorum, hinted handoff, data center outages
  8. Anti-entropy with Merkle trees
  9. System architecture: the write path and the read path

7. Design a Unique ID Generator in Distributed Systems

  1. Requirements
  2. Option 1: Multi-master replication
  3. Option 2: UUID
  4. Option 3: Ticket server
  5. Option 4: Twitter Snowflake ✅
  6. Deep dive and wrap up

Part 4 · Design real systems

Put everything together to design products you use every day.

8. Design a URL Shortener

  1. Requirements and estimation
  2. API endpoints, and 301 vs 302 redirects
  3. How long should the short code be?
  4. Approach 1: Hash + collision resolution
  5. Approach 2: Base-62 conversion ✅
  6. Deep dive: the shortening and redirecting flows
  7. Wrap up

9. Design a Web Crawler

  1. Uses, requirements and estimation
  2. High-level design: the crawler workflow
  3. DFS vs BFS
  4. The URL frontier: politeness, priority, freshness
  5. HTML downloader: robots.txt and performance
  6. Robustness, extensibility and problematic content
  7. Wrap up

10. Design a Notification System

  1. Types of notifications
  2. Gathering contact info
  3. A first design, and its problems
  4. Improved design: queues per channel
  5. Reliability: no data loss, no duplicates
  6. Templates, settings, security, tracking, and the final design

11. Design a News Feed System

  1. Requirements and APIs
  2. High-level design: publishing and building
  3. Fanout on write vs fanout on read
  4. Deep dive: the fanout service
  5. Deep dive: news feed retrieval and the cache layers
  6. Wrap up

12. Design a Chat System

  1. Requirements
  2. Polling vs long polling vs WebSocket
  3. High-level design
  4. Storage, data models and message IDs
  5. Service discovery
  6. 1-on-1 message flow
  7. Syncing messages across multiple devices
  8. Small group chat flow
  9. Online presence
  10. Wrap up

13. Design a Search Autocomplete System

  1. Requirements and estimation
  2. High-level design: gather data, serve queries
  3. The trie (prefix tree)
  4. Optimization: cache the top k at every node
  5. Data gathering service
  6. Query service and trie operations
  7. Scaling the storage: smart sharding
  8. Wrap up

14. Design YouTube

  1. Requirements and estimation
  2. High-level design: the video uploading flow
  3. Video streaming and adaptive bitrate
  4. Video transcoding and the DAG model
  5. Video transcoding architecture
  6. Optimizations: speed, safety and cost
  7. Error handling and wrap up

15. Design Google Drive

  1. Requirements and estimation
  2. Start simple: one server and three APIs
  3. Moving away from one server, and sync conflicts
  4. High-level design
  5. Block servers and delta sync
  6. High consistency and the metadata database
  7. Upload flow, download flow and notifications
  8. Saving storage space, and handling failures
  9. Wrap up

Part 5 · Keep going

Where to go after Volume 1.

16. The Learning Continues

  1. Your system design toolbox
  2. Capstone: combine everything
  3. Real-world systems to study next
  4. How to keep improving

Part 6 · Volume 2

New: the first chapters that follow System Design Interview, Volume 2. More are on the way.

17. Design a Proximity Service

  1. Requirements and scale
  2. Why a plain latitude/longitude query is slow
  3. Geohash: turning a location into a string
  4. Quadtree: split where the businesses are
  5. The architecture
  6. Searching, step by step