A guided path to learning system design, from fundamentals to advanced patterns.
- ACID – Database transaction guarantees
- CAP – Trade-offs in distributed systems
- Partition Tolerance – Handling distributed failures
- Partition vs Sharding – Scaling databases horizontally
- SOLID – Object-oriented design principles
- Strategy Design Pattern – Flexible design patterns
- 12-Factor App Principle – Cloud-native app principles
- NFR – Non-functional requirements like scalability, latency, availability
- Idempotency – Designing reliable operations
- SPOF – Single point of failure
- Six Pillars of System Design – Core pillars overview
- SQL vs NoSQL – Choosing the right database
- Document DB vs Columnar DB – Data models
- Cassandra – High-scale distributed database
- Sharding – Horizontal data partitioning
- Primary Replica Setup – High availability in DBs
- MVCC – Multi-version concurrency control
- Serializable Transactions – Strong consistency in DBs
- Data Isolation – Isolation strategies
- Data Consistency – Ensuring consistent data
- Eventual Consistency – Relaxed consistency models
- Replication – Multi-AZ / Multi-region setups
- Two-Phase Commit – Distributed transaction protocol
- Saga Pattern – Distributed transaction management
- Data Lakes – Centralized analytics storage
- HDFS – Distributed file system
- S3 – Cloud object storage
- Redis Persistence – Durable in-memory data
- Outbox Pattern and Ops Dashboard – Event-driven reliability
- Write-Ahead Logs / Redo Logs – Recovery mechanisms
- CDC – Change data capture
- Caching – Reduce latency
- Cache Eviction Policies – Memory management
- Hotspot / Hot Keys, hot-reads-and-writes – Handling traffic spikes
- Latency – Response time measurement
- Latency vs Throughput – Trade-offs
- CPU & Memory Sizing – Estimating resources
- Backpressure – Avoid overloading services
- Micro-batching – Efficient processing
- Sudden Traffic Spike – Handling bursts
- Buffer Burst – Absorbing load spikes
- Failover Switching
- Fault Tolerence
- Auto Restart
- RTO RPO – Recovery objectives
- Multi-region Deployment
- Resiliency
- SLA – Service guarantees
- Leader Election – Cluster coordination
- Cascading Failures
- Chaos Testing
- CDN – Deliver content closer to users
- Load Balancer – Distribute requests
- Load Balancer vs Reverse Proxy
- API Gateway – Manage microservices
- Apigee
- Nginx
- Geo DNS – Global traffic routing
- HTTP vs HTTPS
- SSL Termination
- Sticky Session / Connection
- L4 vs L7 Load Balancing
- Load Balancer vs Reverse Proxy vs API Gateway
- Push vs Pull Architecture
- Asynchronous Decoupling
- Kafka vs Pulsar vs PubSub
- Kafka vs RabbitMQ
- Redis Streams
- Consumer Lag Monitoring
- Fanout
- Webhooks
- WebSockets
- Operational Transformation / CRDTs
- Encryption
- Cryptography
- JWT
- OAuth2
- Secrets Management
- Threat Detection (SEIM, IDS, IPS)
- OWASP
- SAST vs DAST
- Dependency Vulnerability Checks
- DDOS Protection
- Spring Boot Health Check
- Kubernetes Pods Restart
- Kubernetes ConfigMap
- Kubernetes Ingress
- Creating Docker Image
- Helm
- Prometheus & Grafana
- Telemetry
- Two-tier Architecture
- Project Architecture
- Single Server Design
- CQRS
- Event-driven Architecture
- Mono vs Microservices
- Serverfull vs Serverless
- Deployment Strategy
- Back-of-the-Envelop Estimation
- Phased Approach
- Post Materializer
- Measure First Approach
- Retry Mechanism
- Distributed Locking / Redis Lock / Redlock
- Optimistic vs Pessimistic Locking
- Row Level Locking
- Compare-And-Swap
- Quorum
- Rate Limiting & Distributed Rate Limiter, Rate Limiting Algorithms
- CPU / Memory Estimation
- Elastic Search
- Apache Lucene
- Text Search Engines
- TF-IDF
- Proximity Search
- Cursor Pagination
- Index Fragmentation
- Batch vs Streaming
- Adaptive Streaming
- ABR (Adaptive Bitrate Streaming)
- Transcoding
- Manifest File in Video Chunks Processing
- Chunker Service
- Apache Spark
- HLS / DASH, DASH
- Internet
- UUID
- Snowflake ID
- Vanity URL
- Syllabus
- System Design Problems Key Solutions
- Download & Upload
- 200 vs 201 vs 202
- 301 vs 302
- 429 vs 503
- DOD