Concepts

Learn why systems break under load, how horizontal and vertical scaling work, and how to design for 10x traffic without a 3 a.m. outage.

Learn how load balancers distribute traffic across servers, which algorithms to choose, and how to design a highly-available app tier in any system design interview.

Learn how caching eliminates redundant database reads, which strategy to choose for your write pattern, and how to design a cache layer that survives invalidation at scale.

Learn how a CDN routes users to the nearest edge server, cuts global latency from 300ms to under 30ms, offloads 95%+ of traffic from your origin, and when you actually need one.

Learn how databases organize data for fast retrieval, which storage engine to choose for your workload, and how ACID transactions keep concurrent writes correct at scale.

Learn how database indexes turn slow full-table scans into sub-millisecond lookups, when to use B-tree vs hash vs composite indexes, and when too many indexes hurt more than they help.

Learn how data partitioning splits rows across nodes for horizontal scalability, when to pick range vs hash vs directory-based strategies, and how to handle hotspots and rebalancing.

Master how database replication scales reads, survives failures, and trades off consistency for availability. Learn replica lag, read stale data purposefully, and why your most critical business logic must run on the primary.

Learn what consistency models guarantee, which model fits your data, and how to avoid the silent data corruption that happens when you choose wrong.

Learn why every distributed system must choose between consistency and availability when a partition strikes — and how to make that choice intentionally.

Master the networking protocols, load balancing strategies, and failure-handling patterns that underpin every system design interview — from TCP vs UDP to L4 vs L7 load balancers.

Learn how message queues decouple services, which delivery guarantee fits your workload, and how to build a queue layer that survives consumer failures.

How event-driven systems decouple producers from consumers using events as the primary communication mechanism, covering event types, broker topology, ordering guarantees, and the tradeoffs vs. synchronous calls.

Learn what an API Gateway is, how it works, its trade-offs, and exactly how to talk about it in a system design interview.

Learn how rate limiting caps request throughput per client, which algorithm to choose for your traffic pattern, and how to enforce limits correctly in a distributed system.

Learn how microservices decompose monolithic applications into independently deployable services, when the operational overhead is worth it, and how to avoid the distributed traps that swallow engineering teams.

How distributed services find and communicate with each other in dynamic environments, covering client-side vs. server-side discovery, DNS-based vs. registry-based approaches, and health checking.

Learn how a service mesh eliminates duplicated networking code across microservices, enforces zero-trust mTLS by default, and gives you end-to-end observability without touching your application code.

Strategies for evolving APIs without breaking clients, including URI versioning, Stripe's date-based model, content negotiation, and the compatibility rules that let you ship changes safely.

The three pillars of observability in distributed systems: what each signal type is for, how they complement each other, and how to instrument services for full system visibility.

How distributed tracing tracks a single request across multiple services: spans, trace context propagation, sampling strategies, and how to use traces to diagnose production latency problems.

How SLIs, SLOs, and SLAs work together with error budgets, burn rate alerting, the difference between an SLO target and an SLA contract, and how reliability goals drive engineering decisions.

Master AuthN, AuthZ, RBAC, ABAC, OAuth 2.0, SSO, MFA, M2M auth, mTLS, and Zero Trust so you can design secure systems that interviewers respect and production demands.

How distributed systems agree on a single value despite crashes and network partitions. Covers Raft leader election, Paxos, quorum math, and when consensus is worth its latency cost.

How to coordinate exclusive access to a shared resource across distributed processes. Covers Redis SETNX locks, fencing tokens, Redlock, etcd/ZooKeeper locks, and Martin Kleppmann's critique.

Learn how to serve multiple customers from shared infrastructure without data leakage, using silo, bridge, and pool isolation models with tenant-aware routing.

How data pipelines move and transform data at scale: batch vs. stream processing, Lambda vs. Kappa architecture, ETL vs. ELT, medallion architecture, windowing strategies, and failure handling.

How vector databases store and search high-dimensional embeddings for semantic search, recommendation, and AI applications, including ANN algorithms, similarity functions, and when to use them.

How chaos engineering builds resilience through controlled failure injection, steady-state hypothesis testing, blast radius control, GameDays, and the chaos maturity model from manual to continuous.

What edge computing is and when to use it, edge vs CDN, Cloudflare Workers vs Lambda@Edge cold starts, edge data stores, and when the edge creates more problems than it solves.