System Design Notes and Cheat Sheet
In short
System design notes are short revision notes on how big software systems are built: scaling, load balancing, caching, databases, messaging, APIs, microservices, consistency and reliability. This page has 185 key points across 23 topics, free and with no signup. Each topic links to a longer notes page and to the full lessons, so you can revise the whole field in about an hour and go deeper only where you are weak.
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.
This page is the free part.
The course goes deeper on every topic in these notes
₹1,111 in India$25 everywhere elseonce, for the whole course
The System Design course covers every topic in these notes across a run of lessons, not one page. These 4 alone are about 102 minutes of step-by-step reading, every one with a quiz.
- Local Cache
The fastest cache you can have, and the only one that can disagree with itself.
- Latency
Time delay in system response - most basic performance metric.
- DNS (Domain Name System)
The internet's phone book, how domain names become IP addresses.
- Application Cache
The cache your own code manages, the race hiding in its default pattern, and how often that race actually fires.
all part of
System Design Masterclass
770 lessons · about 287 hours · 18 free to read
₹1,111in India, by UPI
$25everywhere else, by PayPal
It is really nice and good Please join the course
You own this course
Continue with Local Cachepay once,
yours for life
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
Data Engineering
4 lessons- Warehouse vs lake vs lakehouse
- Transaction log and commits
- Delta Lake, Iceberg and Hudi
- Time travel and cleanup
- Small files and compaction
- Optimistic concurrency
- Catalogs and namespaces
- Unity Catalog grants
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
Go deeper on single ideas
- The system design roadmap, in learning order
The same topics as these notes, laid out as a path from basics to advanced.
- Timeouts: how long to wait before giving up
Without one, a stalled dependency can hang the whole system.
- Clock skew: why two servers disagree on the time
Clocks drift, so distributed systems cannot fully trust them.
- Cache stampede: when a hot cache entry expires
Many requests miss at once and all hit the database together.
- Design Kafka: a message queue built on a commit log
A full interview walkthrough of the messaging notes.
- Design a distributed job scheduler
Running timed jobs on time, once, across many machines.
- Design a rate limiter
The rate limiting notes as an interview answer: token bucket vs sliding window, counted across many servers.
- Design a notification system
Queues, fanout and retries applied to push, SMS and email, without sending anything twice.
- Design Ticketmaster
Locking and idempotency when thousands of people want the same seat at once.
- Low level design (LLD) interview questions
The other design round: classes, design patterns and code for a parking lot or a vending machine.
New explainers on AI tools and models
all explainersFrequently asked questions
- What are system design notes?
- System design notes are short revision notes on how big software systems are built: scaling, load balancing, caching, databases, messaging, APIs, microservices, consistency and reliability. This page has 185 key points across 23 topics, free and with no signup. Each topic links to a longer notes page and to the full lessons, so you can revise the whole field in about an hour and go deeper only where you are weak.
- Is this a system design cheat sheet?
- Yes, it works as one. Each topic card lists only its key points, 185 in total, so the whole field fits on one scrolling page. Read a card, check that you can explain every line out loud, and open the topic notes for any line you cannot.
- Do these notes cover all of system design?
- They cover every topic in the course, 23 in all, from core fundamentals through distributed systems, consistency, reliability and capstone designs. A note is a summary, though. The reasons behind each idea, the diagrams and the trade-offs live in the 770 lessons that each topic links to.
- Should I read the notes or the roadmap first?
- If you are new to system design, follow the roadmap, because it puts the topics in learning order. If you have studied before and want to find your gaps fast, start here with the notes. Both pages share one topic list, so you can switch between them at any point.
- 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 18 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.
- Is there a PDF of these system design notes?
- There is no separate PDF file. You can save this page as a PDF with your browser: open the print menu and choose Save as PDF. The page itself stays free and is updated when the course changes, so the web version is always the newest one.
From notes to real understanding
Notes get you through revision. The lessons get you the real thing: interactive diagrams, code, and quizzes across 770 lessons. 18 are free with no signup, and lifetime access is 1,111 rupeesin India or $25 worldwide.
Revising for an interview? Practise the questions too.
Get all 200 questions in the System Design and Distributed Systems pack
Each question has why it is asked, a full answer, what the interviewer listens for, the follow-ups, the common mistakes and a diagram (268 diagrams in all). A PDF you keep, junior to staff level.
India: UPI, cards or netbanking through Razorpay. Elsewhere: card or PayPal. Download at once from My packs.