NotesTopic map
Foundations
Concepts
Reliability
- Reliability: keep working correctly when things go wrong
- Fault Tolerance: stop faults from turning into failures
- Redundancy: spare components take over
- Single Point of Failure: anything whose loss alone takes the system down
- Chaos Engineering: inject faults on purpose so recovery paths stay tested
- Hardware Fault: random, mostly independent; constant at scale
- Software Fault: systematic and correlated; hits every replica at once
- Human Error: the leading cause of outages; design for forgiveness
- Fault Tolerance: stop faults from turning into failures
Scalability
- Scalability: cope as a named load grows while keeping a named performance
- Load Parameters: the few numbers that decide how much work the system does
- Fan-Out on Write: precompute feeds at write time so reads are one lookup
- Latency Percentiles: describe response time as a distribution, not a mean
- Tail Latency Amplification: fan-out turns rare slowness into common slowness
- Little's Law: in-flight = arrival rate × time in system
- Vertical Scaling: a bigger machine, no distribution
- Horizontal Scaling: more machines, shared-nothing
Maintainability
- Maintainability: easy to run, understand and change for years
- Operability: make the operators' job easy and predictable
- Observability: answer unanticipated questions from outputs
- Blameless Postmortem: learn from incidents through systems, not blame
- Accidental Complexity: complexity from our choices, not the problem
- Evolvability: small, compatible, reversible changes
- Rolling Upgrade: old and new versions side by side, compatible both ways
- Canary Release: expose a change to a small slice first
- Cloud vs Self-Hosting: unit cost and control vs elasticity and less ops
- Operability: make the operators' job easy and predictable
Load balancing
- Load Balancer: one stable address in front of a pool of backends
- Load Balancing Algorithms: how a backend is chosen
- Power of Two Choices: two random picks, take the less loaded
- Health Check: active probes and passive outlier detection
- L4 vs L7 Load Balancing: per connection vs per request
- Service Discovery: the live registry of who's in the pool
- Load Balancing Algorithms: how a backend is chosen
Caching
- Caching: a cheaper copy; value set by hit ratio
- Cache-Aside: the app reads through and deletes on write
- Write-Through Cache: write both, acknowledge after the store
- Write-Back Cache: acknowledge from cache, flush later
- Cache Eviction Policy: what to throw out, and what to admit
- Cache Invalidation: TTLs, deletes and change-log-driven purges
- Cache Stampede: everyone misses the same hot key at once
- Content Delivery Network: a global HTTP cache at the edge
Overload
- Timeout: bound every wait; propagate deadlines
- Retry with Backoff: exponential, jittered, at one layer, with a budget
- Circuit Breaker: stop calling a dependency that's failing
- Bulkhead: partition resources to cap blast radius
- Rate Limiting: cap what any one caller may send
- Load Shedding: reject excess early to protect goodput
- Backpressure: tell the producer to slow down
- Cascading Failure: failure spreads by shifting load onto neighbours
- Metastable Failure: a bad state that outlives its trigger
Data ethics
- Data Ethics: deciding what data about people to collect, keep and act on
- Privacy by Design: protection in the architecture from day one
- Data Minimization: collect and keep only what the purpose needs
- Data Retention: per-dataset lifetimes, enforced
- Right to Erasure: deletion as a distributed-systems problem
- Crypto-Shredding: erase every copy by destroying a per-subject key
- Algorithmic Bias: systematically worse outcomes for some groups
- Privacy by Design: protection in the architecture from day one
Systems
- Chaos Monkey · Envoy · Redis · Memcached
Key trade-offs
- Reliability vs cost: redundancy, tooling and operational effort cost money. Cutting corners is fine for a prototype, as long as it's deliberate.
- Independent vs correlated faults: redundancy defeats the first, does nothing for the second.
- Cheap reads vs cheap writes: fan-out on write and caching both move work from read time to write time.
- Retries vs load: every retry hides a fault and adds load at the worst moment; budgets, jitter and shedding keep them honest.
Connections
- Part of
- System Design
- Contains
- BackpressureBulkheadCachingCascading FailureCircuit BreakerData EthicsLoad BalancerLoad SheddingMaintainabilityMetastable FailureRate LimitingReliabilityRetry with BackoffScalabilityTimeout
- In this map
- Fault ToleranceRedundancySingle Point of FailureChaos EngineeringHardware FaultSoftware FaultHuman ErrorLoad ParametersFan-Out on WriteLatency PercentilesTail Latency AmplificationLittle's LawVertical ScalingHorizontal ScalingOperabilityObservabilityBlameless PostmortemAccidental ComplexityEvolvabilityRolling UpgradeCanary ReleaseCloud vs Self-HostingLoad Balancing AlgorithmsPower of Two ChoicesHealth CheckL4 vs L7 Load BalancingService DiscoveryCache-AsideWrite-Through CacheWrite-Back CacheCache Eviction PolicyCache InvalidationCache StampedeContent Delivery NetworkPrivacy by DesignData MinimizationData RetentionRight to ErasureCrypto-ShreddingAlgorithmic BiasChaos MonkeyEnvoyRedisMemcached