System Design

Latency numbers every engineer should know

Vertical vs horizontal scaling

Caching: when, where, what

Load balancers

Database replication

Sharding (horizontal partitioning)

Message queues

CAP theorem

Rate limiting

CDN: edge caching for static assets

Microservices vs monolith

Idempotency

Designing for failure

Mock interview: design URL shortener

Consistent hashing

Bloom filters

Distributed locks (Redlock pattern)

Service discovery (DNS vs registry)

API Gateway at scale: routing, auth, rate-limit, observability

🎯 Review: System design module 1 recap

Backpressure handling

Webhooks vs polling

Event sourcing

CQRS (Command Query Responsibility Segregation)

Sagas for distributed transactions

Read-through vs write-through cache

Cache stampede prevention (singleflight)

Eventual consistency in practice

Optimistic vs pessimistic concurrency

Designing a URL shortener at 100K req/s

Designing a feed (Twitter/Instagram timeline)

Designing a chat system (WhatsApp scale)

Designing rate-limited search

Designing a notification fanout

Capstone: design a multi-tenant SaaS

CDN tier design: push vs pull, cache invalidation

WebSocket scaling: sticky sessions vs broker

Pub/Sub patterns: Kafka, NATS, Redis pub/sub

Backpressure in streaming: windowing, dropping, buffering

Database choice cheatsheet

🎯 Review: System design module 2 recap

Data partitioning vs sharding nuances

Read-your-writes consistency

Linearizability vs eventual consistency

Two-phase commit (and why it's mostly avoided)

Schema evolution (forward/backward compatibility)

Multi-region deployment (active-active vs active-passive)

Disaster recovery: RPO and RTO

Designing a video upload + transcoding pipeline

Designing a payment system

Designing a recommendation system

Designing search autocomplete

Designing a distributed task scheduler

Designing a typeahead/search API for product catalog

Designing a content moderation pipeline

Capstone: design Uber/Lyft-style ride matching

Lambda vs Kappa architectures

Change Data Capture with Debezium

Event sourcing — state is a fold over events

CQRS — separate read and write models

Saga pattern — distributed transactions

🎯 Review: System design module 3 recap

Outbox pattern — atomic 'commit + publish'

Service mesh — mTLS + observability for free

Multi-tenant data isolation

Feature flags at scale

GraphQL Federation

Distributed rate limiting via Redis Lua

SSE vs WebSocket vs long-poll

Push notification fan-out at scale

Search architecture — when to reach for Elasticsearch

Predict: back-of-envelope for global LB

S3 lifecycle — when to move to Glacier

Scenario: cross-region failover drill

RPO vs RTO — pick your tradeoffs

FinOps — attribute and right-size

🏆 Capstone — global SaaS for 10M MAU

🎯 Review: System design module 4 recap

Design URL shortener: capacity math first

Design newsfeed (Twitter/X timeline)

Design chat (WhatsApp scale)

Design Uber: ride-matching at scale

Design Netflix video streaming

Design Stripe payments idempotency

Design Google Docs: collaborative editing

Design Instagram photo upload

Design feature flags service

Design Slack notifications

Design search: Elasticsearch architecture

Design DNS resolver

Design backup + restore

Design CDN cache invalidation

Design Spotify recommendations

Design DDoS protection

Design email service (SendGrid scale)

Design Kafka: log-as-broker

Design GitHub Actions: CI dispatch

Design Calendly: scheduling collisions

Design Stripe webhooks: at-least-once delivery

Design log aggregation (Datadog scale)

Design 2FA flow

Design observability (SLOs and error budgets)

🏆 System Design final capstone