From requirements and capacity estimation to consistency models, data partitioning, caching, messaging, observability and disaster recovery.
Requirements Gathering for System Design: How architects turn a vague problem into scoped, testable requirements before drawing a single box, and how to run the first ten minutes of a design interview.
Functional and Non-Functional Requirements: The difference between what a system does and how well it does it, how to make quality attributes measurable, and how NFRs drive architecture decisions.
Capacity and Traffic Estimation: Back-of-the-envelope math for requests per second, peak load, storage, bandwidth, cache and server counts, with worked examples and the numbers every architect should know.
Scalability: Vertical vs horizontal scaling, stateless services, scaling the data tier, autoscaling and the bottlenecks that actually stop systems from growing.
Availability: Nines and downtime budgets, removing single points of failure, redundancy patterns across zones and regions, and how dependencies multiply unavailability.
Reliability and Fault Tolerance: Designing systems that keep producing correct results when components fail, covering failure modes, redundancy, idempotency, durability and the SRE practices that sustain reliability.
Resilience Engineering: Timeouts, retries with backoff and jitter, circuit breakers, bulkheads, load shedding and graceful degradation, plus how to verify resilience with chaos experiments.
Latency and Throughput: Percentiles, tail latency, Little's Law, the relationship between utilization and queueing delay, and practical techniques to cut latency and raise throughput.
Consistency Models: Linearizability, sequential, causal, read-your-writes and eventual consistency explained with concrete examples, and how to choose the right model per use case.
CAP and PACELC Theorems: What CAP really says (and what it does not), why PACELC is more useful day to day, and how real databases position themselves.
Distributed Transactions: Two-phase commit, sagas, the transactional outbox, idempotent consumers and TCC, with guidance on when each is appropriate and how to avoid needing them.
Data Partitioning and Sharding: Horizontal and vertical partitioning, choosing shard keys, hash vs range vs directory sharding, consistent hashing, hot spots and resharding strategies.
Replication: Leader-follower, multi-leader and leaderless replication; synchronous vs asynchronous; replication lag, failover, split brain and quorum maths.
Caching: Where to cache, cache-aside vs read-through vs write-through vs write-back, eviction, invalidation, stampede protection and consistency trade-offs.
Database Selection: A decision framework for choosing between relational, distributed SQL, key-value, document, wide-column, search, time-series, graph, analytical and vector stores.
Load Balancing: L4 vs L7 load balancers, algorithms, health checks, global traffic management, connection draining and the failure modes of load balancing itself.
Rate Limiting: Token bucket, leaky bucket, fixed and sliding windows; distributed rate limiting with Redis; quotas per tenant; and returning proper 429 responses.
API Gateway: Responsibilities of an API gateway, gateway vs BFF vs service mesh, cross-cutting policies, and the anti-pattern of business logic in the gateway.
Service Discovery: Client-side vs server-side discovery, DNS-based discovery in Kubernetes, registries like Consul and Eureka, and health-aware routing.
Event-Driven Architecture in System Design: Events vs commands, event notification vs event-carried state transfer, delivery guarantees, ordering, schema evolution and where EDA helps or hurts in system design.
Message Queues and Streaming: Queues vs pub/sub vs logs, competing consumers, dead-letter queues, visibility timeouts, ordering and when to choose SQS, Service Bus, RabbitMQ, Kafka or Pub/Sub.
Observability: Logs, metrics, traces and profiles; OpenTelemetry; SLO-based alerting; correlation across services; and controlling observability cost.
Disaster Recovery: RPO and RTO, the four DR strategies from backup-and-restore to multi-site active-active, testing DR, and data-level protection against corruption and ransomware.