Core Concepts

Latency, throughput, bandwidth, and percentiles — the four measurements that appear in every design discussion.

SLIs, SLOs, SLAs, and error budgets. How you define and commit to system behavior — and what happens when you breach it.

SPOF, redundancy, nines, active-active vs active-passive. What "highly available" actually requires you to build.

MTBF, MTTR, RTO, RPO. The difference between a system that rarely fails and one that recovers fast when it does.

Horizontal vs vertical scaling, load balancing at L4 and L7, auto-scaling, and connection draining. How systems grow without breaking.

Graceful degradation, bulkheads, circuit breakers, retries with backoff. How systems survive partial failure without cascading.

WAL, replication, and backups. The mechanisms that ensure data survives node failure, crash, or disaster.

Race conditions, pessimistic and optimistic locking, MVCC, and distributed locks. How systems handle parallel writes without corruption.

Strong, eventual, causal, and monotonic. What "up to date" means in a distributed system and when each model is the right call.

What happens when nodes can't talk. Split brain, quorum decisions, and why partition handling defines your entire consistency strategy.

Consistency vs availability when a partition happens. CP vs AP — and why every distributed system is forced to choose during a split.

Extends CAP to cover normal operation. Even without a partition, you still trade latency against consistency — PACELC names that tradeoff.

Auth, JWT, encryption at rest and in transit. The security primitives that belong in every system design, not just the ones marked "sensitive."

Modeling order flows, workflows, and status transitions as explicit states. The pattern that makes async systems auditable and debuggable.

Non-functional requirements: the hidden constraints that shape every architecture decision before you draw a single box.