System Design Knowledge Base
A structured reference for engineers preparing for system design interviews or building production-grade distributed systems.
What's Covered
| Topic | Description |
|---|---|
| π― 45 Problem Breakdowns | Master syllabus of 45 real-world FAANG interview problems with deep architectural designs |
| π Full System Design Course | Master course: Single server to production infra (Databases, L4/L7 LB, TCP/UDP, APIs, Auth, Multi-tier Caching) |
| Architecture Fundamentals | CAP theorem, consistency models, trade-offs |
| Capacity Planning & Estimation | Back-of-envelope math, traffic/storage estimation |
| Interview Framework | Structured approach to design interviews |
| Scaling Reads | Caching, read replicas, CDN, CQRS |
| Scaling Writes | Sharding, partitioning, write-ahead log |
| Real-Time Updates | WebSocket, SSE, polling strategies |
| Handling Contention | Locks, MVCC, optimistic concurrency |
| 16 Concurrency Concepts | Processes/Threads, Race Conditions, Mutexes, Deadlocks (Coffman), CAS, Thread Pools, Event Loops, DB Locks & Fencing Tokens |
| Large Blob Storage | Object storage, chunking, CDN delivery |
| Multi-Step Processes | Sagas, orchestration, choreography |
| Long-Running Tasks | Job queues, async patterns, progress tracking |
| Microservices Patterns | Service mesh, circuit breaker, API gateway |
| Database Design | Normalization, indexing, partitioning |
| Caching Strategies | Cache aside, write-through, eviction policies |
| Message Queues & Streaming | Kafka, RabbitMQ, pub/sub, event sourcing |
| Data-Driven vs Event-Driven | Paradigms, ACID vs eventual consistency, Outbox, CDC, CQRS |
| API Design | REST, gRPC, GraphQL, versioning |
| Distributed Systems | Consensus, leader election, clock sync |
| Security Patterns | AuthN/AuthZ, rate limiting, zero trust |
| OpenSearch & Splunk Migration | Lucene segments, FSTs, DocValues, Segment Replication, SPL-to-PPL translation, Data Prepper & ISM tiering |
| OpenSearch Query & Search Guide | Filter Context Roaring Bitmaps, PIT + search_after pagination, composite aggregations & Hybrid BM25 + k-NN Vector Search |
| OpenSearch Schema & Operations Guide | Schema design (nested vs flat_object), zero-downtime Alias + _reindex, _bulk tuning, UUIDv7 IDs, _routing & SRE runbooks |
| 60 Days of System Design | Structured 60-day syllabus categorized into 7 modules + 12 high-impact scenario breakdowns |
| Common Interview Questions | Full question bank with discussion points |
How to Use This Guide
- For structured study β Follow the 60 Days of System Design roadmap for a comprehensive 7-module curriculum with scenario deep-dives.
- For interviews β Start with the Interview Framework, then practice with Common Interview Questions.
- For production systems β Jump directly to the relevant pattern topic below.
- For review β Test yourself on trade-offs and edge cases using the scenario breakdowns.
Key Principles to Internalize
- There is no silver bullet β every design choice is a trade-off.
- Identify bottlenecks first β don't optimize prematurely.
- Consistency vs. Availability β know which one your use case needs.
- Data is the hardest part β compute is cheap, storage and consistency are not.
Interview Questions
Q: How do you structure the first 5 minutes of a system design interview?
A: Clarify requirements and constraints, define scale assumptions, identify core entities and APIs, then propose a baseline architecture before deep dives.
Q: What distinguishes a senior-level system design answer from a mid-level one?
A: Seniors make explicit trade-offs, quantify scale, discuss failure modes, and connect design choices to operational concerns like SLOs, cost, and rollout risk.
Q: How do you decide what to design first: API, data model, or infrastructure?
A: Start from user flows and invariants, then model data and APIs, and finally map to infrastructure based on throughput, latency, and consistency requirements.
Q: How should you handle unknown numbers during estimation?
A: State assumptions clearly, use round-number math, and show sensitivity analysis to communicate how the design changes at 10x scale.
Q: What is your framework for discussing consistency trade-offs?
A: Identify correctness requirements per operation, classify tolerance for stale reads, and choose patterns (quorum, idempotency, saga) accordingly.
Q: How do you include reliability in an interview design without getting lost?
A: Cover failure domains, retries/timeouts, backpressure, graceful degradation, and observability hooks in a concise reliability pass.
Q: When do you introduce caching in the interview flow?
A: After baseline bottlenecks are identified. Explain cache key design, invalidation strategy, and consistency implications.
Q: How do you communicate cost-awareness in architecture decisions?
A: Compare options by resource profile (CPU, memory, storage, network, operations), then justify the cheapest design that still meets SLOs.