Numbers Every Engineer Should Know

easy

Scale: N/A — reference table All FAANG, Stripe, Uber

MathCapacity PlanningLatency

Jeff Dean's Latency Numbers Every Programmer Should Know is the canonical reference for back-of-envelope reasoning. Memorize a small set of anchors and derive everything else from them in seconds.

ScaleN/A — reference table

Key Concepts

1. Time anchors by order of magnitude. Nanoseconds (CPU cache, memory): L1 ~0.5 ns, L2 ~7 ns, main memory ~100 ns, mutex lock ~25 ns. Microseconds (compression, intra-DC network): compress 1 KB ~3 µs, send 1 KB over 1 Gbps ~10 µs, read 1 MB from RAM ~250 µs, intra-DC RTT ~500 µs. Milliseconds (storage, inter-region): read 1 MB from SSD ~1 ms, disk seek ~10 ms, read 1 MB from rotational disk ~20 ms, CA ↔ NL round trip ~150 ms.

1. Time anchors by order of magnitude.

2. Throughput anchors. Modern server: 32-64 cores, 128-512 GB RAM, 10-40 Gbps NIC. NVMe SSD: 1-10 GB/s sequential, 500K-1M IOPS. Redis: 100K-1M ops/s per instance. Postgres OLTP: 5K-50K QPS per node. Kafka broker: 100K-1M msgs/s. nginx: 50K+ RPS per core. Envoy: similar; mTLS adds ~30% CPU. CDN PoP: hundreds of Gbps.

2. Throughput anchors.

3. Time math. Seconds in a day ≈ 86,400 ≈ 10^5. Seconds in a year ≈ 3.15 × 10^7. 1B requests/day averaged ≈ 11,574/s. Peak is usually 3-10x average. 1 Gbps ≈ 125 MB/s sustained.

3. Time math.

4. Storage size shortcuts. Text message ~100 B. Tweet ~300 B. User row ~1 KB. Email ~5 KB. Photo 100 KB - 5 MB. HD video ~1 GB/hour. Log line ~500 B; compressed ~80 B. 1 KB = 10^3 B; 1 MB = 10^6; 1 GB = 10^9; 1 TB = 10^12; 1 PB = 10^15 (base-10 in this domain).

4. Storage size shortcuts.

5. Sanity check pattern. Compute the candidate number, then ask: is it physically possible? If your design needs 500 Tbps egress (Netflix peak), the public internet can't carry it — must use in-network CDN. If you need 100M writes/s on one table, you need 1000+ shards. Round to one significant digit; precision is fake confidence.

5. Sanity check pattern.

Latency anchors

L1 cache 0.5 ns
Branch mispredict 5 ns
L2 cache 7 ns
Mutex lock/unlock 25 ns
Main memory 100 ns
Compress 1KB (Zippy) 3 μs
Send 1KB over 1Gbps 10 μs
Read 1MB from RAM 250 μs
Roundtrip same DC 500 μs
Read 1MB from SSD 1 ms
Disk seek 10 ms
Read 1MB from disk 20 ms
Send packet CA→NL→CA 150 ms

Throughput anchors

1 KB = 10^3 B
1 MB = 10^6 B
1 GB = 10^9 B
1 TB = 10^12 B
1 PB = 10^15 B
Seconds/day ≈ 86,400 ≈ 10^5
Seconds/month ≈ 2.6 × 10^6
Seconds/year ≈ 3.15 × 10^7
1B/day averaged ≈ 11,574 ops/s
1M ops/s daily ≈ 86.4B ops/day

Server capacity

Modern server: 32-64 cores, 128-512GB RAM, 10-40 Gbps NIC
NVMe SSD: 1-10 GB/s sequential read, 500K-1M IOPS
Redis (single instance): ~100K-1M ops/s
Postgres OLTP: 5K-50K QPS per node
MySQL: similar; less for write-heavy
Kafka broker: 100K-1M msgs/s
nginx: 50K+ RPS per core
Envoy: similar; mTLS adds ~30% CPU
CDN PoP: hundreds of Gbps; sub-50ms global p99

Storage size estimates

Text message: ~100 B (with metadata)
Tweet: ~300 B (with metadata)
Email: ~5 KB (text + headers)
User row: ~1 KB
Photo: 100 KB - 5 MB
HD video: ~1 GB/hour at decent bitrate
Log line: ~500 B with structured fields
Compressed log: ~80 B/line (10x compression typical)

Bandwidth math

1 Gbps = 125 MB/s sustained
10 Gbps = 1.25 GB/s
100 Gbps = 12.5 GB/s
1 Tbps = 125 GB/s
Send 1 GB over 1 Gbps = 8 seconds
Send 1 TB over 10 Gbps = ~13 minutes
Send 1 PB over 100 Gbps = ~22 hours (assuming sustained)

Sanity checks

Latency < 1 RTT impossible — design around physical limits.

100M users × 100 KB photos × 7 daily backups = 70 TB/day — does the storage budget fit?

Peak factor: average × 5-10. Plan for peak.

Compare with reality: 'Netflix sized for 100M concurrent streams at 5 Mbps → 500 Tbps egress.' If your design exceeds this without infrastructure scale, you're off.

Two nines on QPS: '100K QPS' should be cross-checked with required capacity in cores, replicas, network.