Lesson Overview + Section #01 + RESHADED Checklist + Quiz #1 are unlocked free below (no login required). Unlock all 80 HD video lessons and deep-dive sections — or watch our two free sample video lessons first.
While functional requirements specify what features a system exposes, non-functional characteristics—availability, reliability, scalability, maintainability, and fault tolerance—define how well the architecture performs under scale, hardware degradation, and operational change. Every extra 'nine' of availability, millisecond of p99 latency reduction, or petabyte of durable replication imposes concrete hardware and consistency trade-offs. In system design interviews, translating vague adjectives like 'highly available and fast' into falsifiable numbers (99.99% uptime, p99 < 200 ms, 70% CPU headroom, 3x replication) is how senior candidates justify every box on the canvas.
WHAT YOU WILL MASTER IN THIS LESSON
Calculate serial (A1 * A2) and parallel (1 - (1 - A1)(1 - A2)) composite availability and map SLA 'nines' (99% to 99.999%) to annual/monthly downtime budgets and automation requirements.
Differentiate reliability (MTBF) from availability (MTBF / (MTBF + MTTR)) and design state recovery for workloads sensitive to frequent brief interruptions.
Size horizontally scalable stateless server tiers with realistic utilization headroom (60–70%) to absorb traffic bursts and node failovers without tail-latency collapse.
Formulate measurable interview non-functional requirements where each numeric target directly mandates a specific caching, sharding, replication, or observability mechanism.
Follow this exact sequence from the Intro narration on every system design prompt so you never miss requirements, math, contracts, or the 13-minute deep dive.
0 / 8 Checked
RRequirements & ScopeMin 2–8
Clarify who the users are, 3–4 core functional flows, explicit non-goals, and target latency/availability SLAs before drawing a single box.
Avoid trap: Still gathering requirements at minute 15 squeezes the deep dive where L5/L6 offers are decided.
EBack-of-the-Envelope MathMin 8–12
Compute ONLY numbers that actively change architectural choices: DAU → peak read/write RPS, daily & 5-year storage, bandwidth (or tokens/sec & KV-cache VRAM for AI).
Avoid trap: Spending 10 minutes multiplying irrelevant byte counts that never influence sharding or caching.
SStorage & Data ModelMin 12–15
Define core tables, primary/partition keys, and access indexes. Separate small structured metadata rows (~1 KB) from bulk binary blobs (S3 + CDN).
Avoid trap: Picking Cassandra or NoSQL by buzzword when 40 writes/s & 3 TB fit cleanly on one indexed SQL primary + replicas.
AAPIs & Wire ContractsMin 15–17
Write 3–4 concrete REST/gRPC/SSE/WebSocket endpoints with request/response shapes, cursor pagination, and Idempotency-Key headers on mutations.
Avoid trap: Hand-waving client-server contracts and discovering missing parameters halfway through the deep dive.
HHigh-Level DesignMin 17–27
Draw the simplest end-to-end working read and write paths first. Every box on the board must trace back to a stated requirement or number.
Avoid trap: Reciting a memorized 12-microservice Kafka mesh before proving why a simpler synchronous path breaks.
DDetailed Design (Deep Dive)Min 27–36
Proactively audit your high-level diagram, name the top 2 bottlenecks (hot partitions, fan-out skew, lock contention, GPU saturation), and go deep on internals.
Avoid trap: Waiting passively for the interviewer to rescue pacing or skimming every box at shallow surface depth.
EEvaluation & Failure ModesMin 36–41
State what each architectural choice COSTS you, and trace graceful degradation when cache, queue, external vendor, or primary DB fails.
Avoid trap: Assuming happy-path uptime or placing slow 3-second external calls inline on revenue-critical write paths.
DDistinctive FeatureMin 41–45
Solve the signature hard problem unique to this prompt (e.g., double-entry ledger idempotency, Geohash dispatch locks, OT/CRDT sync, or SSE token streaming).
Avoid trap: Spending 20 minutes on generic login/CRUD tables and zero time on the core distributed challenge.
INTERVIEWER SCORECARD · WHAT MAKES A STRONG HIRE?
5 Signals Bar Raisers Grade (L4 vs. L5 Senior vs. L6 Staff)
Senior (L5 / E5 / Senior SDE) Bar — Autonomous Pacing, Depth & Proactive Trade-Offs: Owns the 45-minute clock without prompting, derives every component quantitatively, surfaces failure modes (hot shards, stampedes, dual writes) BEFORE being asked, and defends consistency vs. latency trade-offs.
1. Scoping
✓ STRONG HIRE SIGNAL
Clarifies users, read/write skew, p99 latency, consistency bounds, and explicit non-goals in minutes 2–8.
✗ NO-HIRE RED FLAG
Jumps straight into drawing load balancers and microservices at minute 2 without asking a single question.
2. Right-Sized Design
✓ STRONG HIRE SIGNAL
Starts with the simplest working architecture justified by the math (e.g., 1 NVMe SQL primary + replicas + Redis for 40 writes/s & 3 TB).
✗ NO-HIRE RED FLAG
Recites a memorized Kafka + multi-DC Cassandra diagram that contradicts their own traffic calculations.
3. Technical Depth
✓ STRONG HIRE SIGNAL
Drives deep into 1–2 hard bottlenecks (partition keys, hot-key mitigation, transactional outbox, KV-cache batching) at minute 27.
✗ NO-HIRE RED FLAG
Skims across 12 boxes at identical buzzword depth and runs out of time before the deep dive.
4. Explicit Trade-Offs
✓ STRONG HIRE SIGNAL
Uses 3-part reasoning: 'A queue here because SMTP spikes to 3 s; checkout stays <60 ms, and we accept eventual email delay + retry dedup.'
✗ NO-HIRE RED FLAG
Name-drops tools ('We put Kafka and ZooKeeper here') without stating the alternative or operational cost.
5. Communication
✓ STRONG HIRE SIGNAL
Thinks aloud every 30–45s, checks alignment at phase transitions, and treats 'What if X fails?' as a cue for where points are awarded.
✗ NO-HIRE RED FLAG
Goes silent for 5 minutes while drawing or defends a flawed assumption defensively when nudged.
Key Takeaway: Availability (uptime / (uptime + downtime)) is measured in 'nines'; sequential service chains multiply to lower availability, parallel independent replicas raise it, and crossing 99.99% into 99.999% (25.9 s/month downtime) requires zero-human automated failover.
ARCHITECTURE / DATA FLOW DIAGRAM
The SLA Table of Nines and Human Reaction Limits
Availability measures the percentage of elapsed wall-clock time during which a system successfully responds to valid user requests: Availability = Uptime / (Uptime + Downtime). Because production targets cluster near 100%, engineers express SLAs by counting 'nines' across an 8,760-hour year (365 days) or a 720-hour month (30 days). Each additional nine shrinks the permitted downtime budget by 10x, creating a sharp operational inflection point: at three nines (99.9%, 43.2 min/month), an on-call engineer can receive a page, inspect dashboards, and trigger a manual failover; at five nines (99.999%, 25.9 s/month), a human cannot even unlock a laptop before the entire monthly error budget evaporates.
Availability Tier
Annual Downtime Budget
Monthly Downtime Budget
Minimum Failover Architecture Required
99% (Two Nines)
3.65 days
7.20 hours
Single-AZ deployment with automated process restarts & daily backups
Composite Availability: Serial Chains vs Parallel Redundancy
Real request paths traverse multiple components, and topology dictates how individual component SLAs combine. When a request requires two components in series (Web Server -> Database), both must be healthy simultaneously, so their availabilities multiply: two 99.9% services in series yield 0.999 * 0.999 = 0.998001 ≈ 99.8% (doubling downtime!). Conversely, when two redundant replicas (Database A and Database B, each 99.9% available with 0.001 unavailability) operate in parallel so either can serve requests independently, the pair fails only when both are down concurrently: P(both down) = 0.001 * 0.001 = 0.000001, raising theoretical availability to 1 - 0.000001 = 99.9999% (six nines).
Microservice chain tax: A synchronous call graph traversing 10 serial microservices each running at 99.9% drops end-to-end availability to 0.999^10 ≈ 99.0%—a primary reason to minimize synchronous fan-out depth.
Redundancy math: Parallel active-active or automated hot-standby failover (1 - (1 - A)^k for k independent replicas) is how cloud architectures synthesize four-nines or five-nines systems out of three-nines commodity servers.
Why Correlated Failures Break Naive Probability Math
Multiplying (1 - A_1) * (1 - A_2) strictly assumes statistical independence between failures. In real production postmortems, Database A and Database B frequently fail at the exact same second due to common-mode (correlated) triggers: a shared availability-zone power loss, an expired root TLS certificate, a buggy schema migration applied globally, or a poison query that crashes Database A and immediately fails over to crash Database B.
Interview Signal: When claiming multi-nine availability via redundancy in an interview, note how you preserve fault independence: spread replicas across physically separate Availability Zones (AZs), stagger configuration/code rollouts incrementally across fault domains, and shed poison queries before failover.
SECTION 02 OF 6
2. Reliability
🔒 PRO SECTION
Key Takeaway: Reliability measures the probability of uninterrupted, correct operation over an interval (MTBF), whereas availability measures the fraction of time reachable (MTBF / (MTBF + MTTR)); a system crashing for 1 s every hour achieves 99.97% availability yet fails every multi-hour stateful job.
Section 1 + Checkpoint Quiz #1 are unlocked free outside the paywall. Unlock all architecture slides, QPS & sharding trade-off tables, and all 80 narrated HD video lessons with Full Access — or inspect our sample payment system lesson first.
Key Takeaway: Scalability is the capacity to absorb growing load while preserving latency SLAs—moving beyond vertical single-host ceilings via stateless horizontal scale-out sized with 60–70% utilization headroom.
Section 1 + Checkpoint Quiz #1 are unlocked free outside the paywall. Unlock all architecture slides, QPS & sharding trade-off tables, and all 80 narrated HD video lessons with Full Access — or inspect our sample payment system lesson first.
Key Takeaway: Because 80%+ of software lifecycle cost occurs after launch, maintainable architectures optimize operability, lucidity, and modifiability—compressing 03:00 incident recovery (MTTR) from 5 hours to 5 minutes.
Section 1 + Checkpoint Quiz #1 are unlocked free outside the paywall. Unlock all architecture slides, QPS & sharding trade-off tables, and all 80 narrated HD video lessons with Full Access — or inspect our sample payment system lesson first.
Key Takeaway: A fault is a single component breaking, whereas a failure is a user-visible service outage; fault-tolerant systems mask faults behind f + 1 / 2f + 1 data replication and periodic compute checkpointing.
Section 1 + Checkpoint Quiz #1 are unlocked free outside the paywall. Unlock all architecture slides, QPS & sharding trade-off tables, and all 80 narrated HD video lessons with Full Access — or inspect our sample payment system lesson first.
6. Non-Functional Requirements for System Design Interviews
🔒 PRO SECTION
Key Takeaway: In interviews, convert every qualitative NFR (available, fast, durable) into a concrete metric (99.99%, p99 < 200 ms, 3x copies) so each number directly earns and justifies a specific architectural component.
Section 1 + Checkpoint Quiz #1 are unlocked free outside the paywall. Unlock all architecture slides, QPS & sharding trade-off tables, and all 80 narrated HD video lessons with Full Access — or inspect our sample payment system lesson first.
In "Availability" (The SLA Table of Nines and Human Reaction Limits), how does a production-grade design handle "99.9% (Three Nines)" (Minimum Failover Architecture Required)?