Curriculum
15 levels · 275 chapters. Deep dives include diagrams, code, quizzes, failure drills and challenges.
Foundations
The mental models everything else is built on.
Horizontal Scaling
Vertical Scaling
Load Balancer
Reverse Proxy
Forward Proxy
API Gateway
Stateless Services
Stateful Services
Monolith
Modular Monolith
Microservices
Service Discovery
Networking & Protocols
How bytes actually travel between machines.
DNS
HTTP
HTTPS
HTTP/1.1
HTTP/2
HTTP/3
TCP
UDP
WebSockets
Server-Sent Events
Long Polling
Polling
REST
GraphQL
gRPC
RPC
API Versioning
Pagination
Cursor Pagination
Rate Limiting
Throttling
Backpressure
Databases
Storage engines, indexing, transactions and replication.
SQL vs NoSQL
Relational Databases
Document Databases
Key-value Databases
Column-oriented Databases
Graph Databases
Indexes
Primary Index
Secondary Index
Composite Index
Covering Index
Database Query Optimization
Execution Plans
Transactions
ACID
Isolation Levels
MVCC
Optimistic vs Pessimistic Locking
Deadlocks
Replication
Leader-Follower Replication
Multi-Leader Replication
Read Replicas
Partitioning
Sharding
Consistent Hashing
Database Federation
Denormalization
Normalization
N+1 Query Problem
Connection Pooling
Database Failover
Point-in-time Recovery
Caching
Making the hot path fast without lying to your users.
Caching Fundamentals
Local Cache
Distributed Cache
Redis
Memcached
Cache Aside
Read Through
Write Through
Write Behind
Write Around
Cache Invalidation
Cache Eviction
Cache Stampede
Cache Avalanche
Cache Penetration
Hot Keys
Distributed Cache Consistency
CDN
Browser Cache
HTTP Cache Headers
ETag
Distributed Systems
Coordinating machines that fail independently.
CAP Theorem
Strong Consistency
Eventual Consistency
Causal Consistency
Distributed Transactions
Two-Phase Commit
Consensus
Leader Election
Quorum
Distributed Locks
Clock Synchronization
Logical Clocks
Vector Clocks
Split Brain
Network Partitions
Distributed IDs
Snowflake IDs
Idempotency
Exactly Once Processing
At Least Once Delivery
At Most Once Delivery
Messaging & Event-Driven
Queues, brokers and asynchronous architectures.
Message Queue
Message Broker
Kafka
RabbitMQ
Pub/Sub
Consumer Groups
Partitions
Offsets
Acknowledgements
Retry
Exponential Backoff
Dead Letter Queue
Poison Messages
Idempotent Consumers
Event-driven Architecture
Outbox Pattern
Inbox Pattern
Saga Pattern
Orchestration
Choreography
Event Sourcing
CQRS
Change Data Capture
Architecture Patterns
How to structure code so it survives growth.
Layered Architecture
Clean Architecture
Hexagonal Architecture
Onion Architecture
DDD
Aggregates
Bounded Contexts
Anti-Corruption Layer
Repository Pattern
Unit of Work
Dependency Injection
SOLID
Microservices vs Modular Monolith
Serverless Architecture
Reliability & Resilience
Designing for the failures that will happen.
Fault Tolerance
High Availability
Redundancy
Failover
Graceful Degradation
Timeouts
Retries
Jitter
Circuit Breaker
Bulkhead Pattern
Health Checks
Disaster Recovery
RTO
RPO
Multi-region Architecture
Active-Active
Active-Passive
Blue-Green Deployment
Canary Deployment
Feature Flags
Chaos Engineering
Security
Protecting data, identity and the perimeter.
Authentication
Authorization
Sessions
Cookies
JWT
Refresh Tokens
OAuth 2.0
OpenID Connect
RBAC
ABAC
API Keys
Secrets Management
Encryption at Rest
Encryption in Transit
Hashing
Salting
CORS
CSRF
XSS
SQL Injection
DDoS Basics
Zero Trust Concepts
Least Privilege
Observability
Knowing what your system is doing in production.
Logging
Structured Logging
Metrics
Tracing
Distributed Tracing
Correlation ID
OpenTelemetry Concepts
Dashboards
Alerting
SLI
SLO
SLA
Error Budgets
Incident Investigation
Frontend System Design
Architecting the client the same way you architect the server.
SPA
SSR vs CSR
SSG
ISR
React Architecture
React Server Components
Server Components vs Client Components
Frontend State Management
Server State
React Query Concepts
Optimistic Updates
Component Architecture
Atomic Design
Micro-frontends
BFF — Backend for Frontend
Code Splitting
Lazy Loading
Core Web Vitals
Image Optimization
Error Boundaries
Frontend Accessibility
Frontend Testing Strategy
Design Systems
Not System Design — building the shared UI language of a product.
What is a Design System?
Design Tokens
Design System Architecture
Typography
Spacing
Grid
Breakpoints
Primitive Components
Composite Components
Component Variants
Controlled vs Uncontrolled Components
Headless Components
Theming
Versioning
Semantic Versioning
Monorepos
Visual Regression Testing
Deprecation Strategy
Governance
Multi-brand Design Systems
Performance & Scalability
Latency, throughput and how to plan for growth.
Latency
Throughput
Concurrency
CPU-bound Tasks
I/O-bound Tasks
Async Processing
Batch Processing
Streaming
Compression
Auto Scaling
Hot Partitions
Bottleneck Identification
Load Testing
Stress Testing
Capacity Planning
Estimation
Back-of-the-envelope math for interviews and capacity.
Interview Preparation
Turning knowledge into a structured interview performance.