High-Level Design
Scalability, databases, caching, load balancing, and real system design interview questions.
Foundations & Approach
What Is System Design?
What system design actually is, why companies ask it, and what interviewers really look for.
How to Approach System Design
A step-by-step framework for tackling any system design interview in 45 minutes.
Requirements Gathering
How to break down system design problems into functional and non-functional requirements.
Back-of-the-Envelope Estimation
Quick math techniques to estimate QPS, storage, and bandwidth for system design interviews.
Design Principles and Trade-offs
Key design principles and the trade-offs we constantly make in system design.
Core Building Blocks
DNS and How the Internet Works
What happens when we type a URL, and why DNS matters in system design.
Load Balancers
What load balancers are, how they distribute traffic, and common algorithms.
Caching
What caching is, where to cache, eviction policies, and invalidation strategies.
Content Delivery Networks (CDNs)
How CDNs work, push vs pull strategies, and when to use them in system design.
Message Queues
Async processing with message queues: patterns, use cases, and popular tools like Kafka and RabbitMQ.
Proxies and Reverse Proxies
Forward proxies vs reverse proxies, what they do, and where they fit in system design.
Database Deep Dive
SQL vs NoSQL
When to use relational databases vs NoSQL, types of NoSQL, and how to pick the right one.
Database Indexing
How indexes work, when to use them, and the trade-offs between read speed and write overhead.
Database Replication
How databases copy data across servers for availability, fault tolerance, and read scaling.
Database Sharding
Splitting data across multiple databases to handle massive scale.
Consistent Hashing
How consistent hashing distributes data across nodes while minimizing disruption when nodes change.
ACID and Transactions
Understanding ACID properties, transaction isolation levels, and when strong guarantees matter.
Scalability Patterns
Horizontal vs Vertical Scaling
The two fundamental ways to handle more traffic — bigger machines or more machines.
Microservices vs Monolith
Understanding the two major architecture styles and when to use each one.
API Gateway
The single entry point that sits in front of our microservices and handles cross-cutting concerns.
Denormalization and Read-Write Separation
Trading data duplication for read performance, and splitting reads from writes to scale independently.
Blob Storage and Object Storage
How we store and serve large files like images, videos, and documents at scale.
Reliability & Consistency
CAP Theorem
Why distributed systems can only guarantee two out of three: consistency, availability, and partition tolerance.
Consistency Models
From strong to eventual — understanding the different consistency guarantees and when to use each.
Failover and Redundancy
Keeping systems alive when things break — active-passive, active-active, and the nines of uptime.
Circuit Breaker and Bulkhead Patterns
Preventing cascading failures in distributed systems with circuit breakers, bulkheads, and smart retries.
Monitoring, Logging, and Alerting
The three pillars of observability — metrics, logs, and traces — and why we can't run a system without them.
Communication Protocols
REST API Design
How to design clean, intuitive REST APIs — methods, status codes, versioning, and pagination.
GraphQL
A query language for APIs that lets clients ask for exactly the data they need — no more, no less.
WebSockets
Persistent, bidirectional connections between client and server for real-time communication.
gRPC and Protocol Buffers
High-performance RPC framework using binary serialization — why it's the go-to for microservice-to-microservice communication.
Polling, Long Polling, and Server-Sent Events
Three approaches to getting real-time updates from the server — from simple polling to SSE.
Advanced Patterns
Rate Limiting
What rate limiting is, the main algorithms behind it, and where to implement it in our systems.
Advanced Caching Patterns
Cache-aside, read-through, write-through, write-behind, and how to handle cache stampedes.
Search and Indexing
How full-text search works, inverted indexes, and when to reach for Elasticsearch.
Event Sourcing and CQRS
Storing events instead of state, separating reads from writes, and when these patterns make sense.
Distributed Consensus
How distributed nodes agree on things: leader election, Raft, split-brain, and tools like etcd and ZooKeeper.
Real System Design Questions
Design a URL Shortener (TinyURL)
Complete system design for a URL shortening service like TinyURL or bit.ly.
Design a Rate Limiter
Complete system design for a distributed rate limiter to protect APIs from abuse and overload.
Design a Chat System (WhatsApp)
Complete system design for a real-time messaging service like WhatsApp or Facebook Messenger.
Design a Social Media Feed (Twitter/X)
Complete system design for a social media news feed like Twitter's home timeline.
Design a Video Streaming Platform (YouTube)
Complete system design for a video streaming platform like YouTube or Netflix.
Design a Ride-Sharing Service (Uber)
Complete system design for a ride-sharing platform like Uber or Lyft.
Design a File Storage Service (Dropbox)
Complete system design for a cloud file storage and sync service like Dropbox or Google Drive.
Design an E-Commerce Platform (Amazon)
Complete system design for an e-commerce platform like Amazon with product catalog, ordering, and payment.