System design handbook

The vocabulary every design discussion uses: scale, latency, availability, estimation and consistency.

• Core design challenges
• Non-functional requirements
• Scalability
• Latency vs throughput
• Availability and SLOs

How requests travel: DNS, HTTP, transports, API styles, real-time channels, load balancers and CDNs.

• DNS
• HTTP versions
• TCP vs UDP
• REST vs gRPC vs GraphQL
• API design

Choosing and scaling storage: data models, indexes, replication, sharding, transactions, search and blobs.

• SQL vs NoSQL
• Relational databases
• NoSQL databases
• Key-value databases
• Document databases

Making reads fast without serving wrong data: placement, strategies, eviction and invalidation.

• Caching basics
• Cache strategies
• Eviction policies
• Invalidation and stampedes
• Cache key design

Decoupling work in time: queues, pub/sub, event logs, delivery guarantees and distributed transactions.

• Message queues
• Pub/sub
• Event streaming (Kafka)
• Delivery guarantees
• Idempotency

Getting many machines to agree: failures, quorums, consensus, leaders, locks, clocks, IDs, gossip and CRDTs.

• Partial failure and fallacies
• Two generals and FLP
• Quorums
• Dynamo-style KV stores
• Write-ahead log

Staying up when parts fail: rate limits, timeouts, circuit breakers, shedding load and recovering from disasters.

• Rate limiting
• Circuit breakers
• Fallbacks
• Timeouts and retries
• Load shedding

Shaping whole systems: service boundaries, dataflow, discovery, serverless, API conventions and fan-out.

• Monolith vs microservices
• Sync vs async communication
• Database per service
• Stateless vs stateful
• Service discovery

Knowing who is calling, what they may do, and keeping data private in transit and at rest.

• Authentication
• Authorization
• Encryption

The specific mechanisms behind classic design questions: typeahead, video delivery, payments, uploads and scheduling.

• Video streaming (HLS, DASH)
• Payments and ledgers
• Resumable uploads
• Job scheduling

Designing the code inside a service: object-oriented design, SOLID principles and the patterns LLD rounds expect.

• HLD vs LLD
• SOLID principles
• Design patterns

Move data from operational sources into trusted, queryable products with reliable pipelines and clear ownership.

• Data engineering interview
• Data engineering architecture
• ETL vs ELT
• Backfill and reprocessing
• Pipeline error handling

Kimball-style warehouse modeling for interviews: grain, facts, dimensions, history, integration, and two complete worked models.

• Modeling interview guide
• Dimensional modeling
• Four-step design process
• Fact table types
• Dimension techniques

Connect data, training, features, model deployment, online inference and feedback into a system that can be operated.

• ML system architecture
• Feature stores
• Recommendation systems
• Model serving
• ML evaluation

Build useful AI products around models with retrieval, tools, safety, evaluation and reliable user-facing behavior.

• AI application architecture
• RAG architecture
• Vector databases
• LLM serving

Running systems in production: containers, Kubernetes, infrastructure as code, delivery, observability and incidents.

• Containers vs VMs
• Kubernetes architecture
• Infrastructure as code
• CI/CD pipelines
• Deployment strategies

Client-side system design: rendering, state, caching, performance, offline sync and shipping to millions of devices.

• Frontend interview framework
• CSR vs SSR vs SSG
• Core Web Vitals
• State management
• Browser caching