Free quick reference
System Design Notes and Cheat Sheet
A fast, free way to revise the whole field. Every topic in system design is laid out here as a scannable set of notes, so you can review the key ideas in an hour the night before an interview, or use it as a map while you study. Each section links straight to the full lesson and to the glossary when you need to go deeper on a single term.
Foundation
Core Fundamentals
26 lessons- Latency vs Throughput
- Vertical vs Horizontal Scaling
- Stateless vs Stateful
- Caching & Load Balancing
- Idempotency & Timeouts
- ACID vs BASE
- SQL vs NoSQL
- REST APIs & Schemas
Load Balancing and Proxies
26 lessons- DNS and routing basics
- Load balancer algorithms
- Forward vs reverse proxy
- Routing strategies
- Sessions and affinity
- Global load balancing
- API gateways
- CDNs
Caching Strategies
36 lessons- Cache layers and placement
- Read patterns (cache-aside, read-through)
- Write patterns (write-through, write-back)
- TTL, eviction, and invalidation
- Stampede prevention
- Loading and prefetching
- Distributed caching
- Tools: Redis, Memcached, Varnish
Database Fundamentals
31 lessons- Indexing & B-Trees
- Normalization vs Denormalization
- Query Optimization
- Views & Materialized Views
- Replication & Read Replicas
- Partitioning Strategies
- Sharding
- Maintenance: Vacuum, Compaction, Reindex
Intermediate
Database Types and Storage
39 lessons- Storage layers: file, block, object, blob
- Row vs columnar storage
- NoSQL families: key-value, document, graph
- Search and inverted indexes
- Vector databases and ANN
- Storage engine internals: LSM trees, bloom filters
- Polyglot persistence and distributed SQL
- Storage tiering: hot, warm, cold, archive
Data Replication and Distribution
31 lessons- Sync vs Async Replication
- Replication Lag
- Replication Topologies
- Active-Active vs Active-Passive
- Consistent Hashing
- Data Partitioning
- Change Data Capture
- Multi-Region Geo-Replication
API Design and Protocols
28 lessons- REST vs GraphQL vs gRPC
- Binary encodings (Protobuf, Avro)
- Rate limiting algorithms
- Idempotency and safe retries
- API versioning
- HTTP/2 and HTTP/3 transport
- Backend for Frontend
- Schema registry and contracts
Messaging and Event Systems
41 lessons- Message Queues and Pub/Sub
- Delivery Guarantees
- Idempotency and Deduplication
- Dead Letter and Poison Messages
- WebSockets and SSE
- Event-Driven Architecture
- Routing and Aggregation Patterns
- Transactional Outbox and Inbox
Microservices Architecture
36 lessons- Monolith vs Microservices
- Domain-Driven Design & Bounded Contexts
- Database per Service
- Resilience Patterns
- Service Discovery & Mesh
- Choreography vs Orchestration
- Migration Patterns
- Container Patterns
Cloud Infrastructure
45 lessons- VPC and Subnets
- CIDR and IP Addressing
- NAT and Gateways
- IaaS / PaaS / SaaS
- Serverless and Cold Start
- Regions and Availability Zones
- Private Connectivity
- Bastion and Segmentation
Kubernetes and Containers
22 lessons- Containers and images
- Registries and versioning
- Declarative orchestration
- Controllers and reconciliation
- Workload types
- Auto-scaling
- Storage and networking
- Operators and CRDs
- Container security
Web Content Delivery
31 lessons- Rendering: CSR, SSR, SSG, ISR
- Compression (Gzip, Brotli)
- Image optimization & formats
- Lazy & responsive loading
- Browser storage & service workers
- Offline-first PWAs
- Video & adaptive streaming
- Asset pipeline & edge delivery
DevOps and CI/CD
36 lessons- Continuous Integration
- Continuous Delivery vs Deployment
- Branch Strategies and Version Control
- Build and Test Automation
- Blue-Green, Canary, Rolling
- Feature Flags
- Infrastructure as Code
- GitOps
Security Architecture
57 lessons- Authentication
- Authorization and access control
- Encryption at rest and in transit
- TLS, certificates and PKI
- OAuth, SSO and federation
- JWT and session management
- Zero trust and defense in depth
- Secrets and key management
Observability and Monitoring
60 lessons- Logs, Metrics, Traces
- Golden Signals (RED & USE)
- SLI / SLO / SLA
- Error Budgets
- MTTD / MTTA / MTTR
- Distributed Tracing
- Percentiles & Histograms
- Prometheus + Grafana + OTel
Data Governance and Compliance
23 lessons- Validation and Schema Checks
- Data Quality and Profiling
- Cleansing and Transformation
- PII Handling
- Masking vs Anonymization vs Pseudonymization
- Audit Logging
- Retention and Lifecycle
- GDPR and Compliance Monitoring
Advanced
Distributed Systems Core
24 lessons- CAP theorem and partitions
- Consensus and quorum
- Leader election and locks
- Logical clocks and ordering
- Replica repair (gossip, read repair)
- Distributed transactions and sagas
- Event sourcing and CQRS
- Actor model and reactive systems
Consistency Models
21 lessons- Linearizability
- Sequential & Causal Consistency
- Session Guarantees (read-your-writes)
- Serializability
- Snapshot Isolation
- CRDTs & Operational Transformation
- Conflict Resolution
- Write-Ahead Logging & PITR
Stream and Batch Processing
36 lessons- Batch vs Streaming
- ETL and ELT
- Windowing
- Watermarks and Late Data
- Stateful Processing
- Exactly-Once Semantics
- Lambda vs Kappa
- Data Mesh and Lineage
Reliability and Resilience
85 lessons- Availability and SLOs
- Backups and Disaster Recovery
- Failover Strategies
- Resilience Patterns
- Incident Response
- Chaos Engineering
- Error Budgets and Toil
- Safe Deployments
Security Testing and Operations
12 lessons- Code Reviews
- SAST and Static Analysis
- SCA and Dependency Risk
- DAST and Vulnerability Scanning
- Penetration Testing
- Bug Bounty Programs
- SIEM and Log Correlation
- IDS vs IPS
Capstone
System Design Capstone Projects
20 lessons- Requirements and scope
- Capacity estimation
- High-level architecture
- Fan-out and feeds
- Idempotency and correctness
- Caching and read scale
- Multi-region and failover
- RAG and AI platforms
Frequently asked questions
- Are these system design notes free?
- Yes. This page is a free quick-reference hub organized by topic, with the key ideas for each area and links into the lessons and the glossary. The first eleven foundation lessons are also free with no signup.
- How do I use these notes for interview prep?
- Use them as a revision checklist. The day before an interview, scan each topic and make sure you can explain every key idea in a sentence. Anything you cannot explain, open the linked lesson or glossary term and fix the gap. The notes are deliberately scannable so you can review the whole field in under an hour.
- What topics does a system design interview cover?
- The common ones are scalability and the core metrics, load balancing, caching, databases and indexing, SQL versus NoSQL, replication and sharding, consistency models, messaging and queues, API design, microservices, and reliability patterns like circuit breakers and failover. Every one of those has its own section here.
- Where can I find definitions of individual terms?
- The glossary has a dedicated, citable page for hundreds of system design terms, each with an answer-first definition, real-world examples, and a diagram where it helps. Each note section links to the matching topic, and the glossary covers the individual terms.
From notes to real understanding
Notes get you through revision. The lessons get you the real thing: interactive diagrams, code, and quizzes across 766 lessons. Eleven are free with no signup, and lifetime access is 299 rupees in India or 5 dollars worldwide.