# System Design Calculator

> A free, zero-dependency browser tool for back-of-the-envelope system design calculations. Useful during technical interviews, architecture reviews, and capacity planning.

## What it does

The calculator gives instant estimates for nine core system design dimensions. All inputs accept shorthand notation (10m = 10 million, 1.5b = 1.5 billion, 500k = 500,000). Results update live. No account, no server, no data sent anywhere.

- **Users & Traffic** -- converts Daily Active Users (DAU) to average QPS, peak QPS, peak read QPS, and peak write QPS given requests/user/day, peak ratio, and read:write ratio
- **Storage** -- total disk required given records/day, bytes/record, replication factor, retention period in days, and index overhead fraction
- **Bandwidth** -- ingress and egress bandwidth (and monthly/yearly totals) from QPS x request size and QPS x response size
- **Throughput & Concurrency** -- applies Little's Law (L = lambda*W) to find total in-flight requests and per-server concurrency and CPU core hint
- **Cache Sizing** -- sizes a Redis/Memcached tier using a hot-fraction (80/20 rule) with per-item size and overhead fraction
- **RAM per Server** -- estimates per-server memory for session/connection state given concurrent users, bytes/session, server count, and headroom fraction
- **Media Streaming** -- peak bandwidth and total storage for audio/video platforms given concurrent viewers, bitrate, upload hours/day, encoding versions, and retention
- **AI/LLM GPU Inference** -- number of GPUs required given model parameter count, bytes per parameter, GPU VRAM, GPU throughput (tokens/sec), and target RPS
- **WebSocket / Real-time** -- server count and bandwidth for persistent-connection services given concurrent connections, messages/sec, message size, fan-out, and per-connection memory

## Key formulas

```
QPS_avg    = DAU x requests_per_user_per_day / 86400
QPS_peak   = QPS_avg x peak_to_average_ratio

Storage    = records_per_day x bytes_per_record x retention_days
             x (1 + index_overhead) x replication_factor

Bandwidth  = QPS x payload_bytes   (per direction)

Concurrency (Little's Law) = QPS x latency_seconds

Cache      = total_items x hot_fraction x bytes_per_item x (1 + overhead)

RAM/server = concurrent_users x bytes_per_session / servers x (1 + headroom)

Media peak BW      = concurrent_viewers x bitrate_Bps
Media total storage = upload_hours_per_day x bitrate_Bps x 3600
                      x encoding_versions x retention_days x replication

AI GPUs (memory)    = ceil((model_params_B x bytes_per_param x 1e9
                       + batch_size x kv_bytes_per_req) / gpu_vram_bytes)
AI GPUs (throughput) = ceil(target_rps x tokens_per_req / gpu_tokens_per_sec)
AI GPUs total       = max(GPUs_memory, GPUs_throughput)

WebSocket servers   = ceil(concurrent_conns x mem_per_conn / server_mem)
WebSocket BW        = concurrent_conns x msg_per_conn_sec x msg_bytes x (1 + fan_out)
```

## Reference cheatsheet

The site includes a static reference page with:

- **Latency numbers** -- L1 cache 1 ns, L2 4 ns, main memory 100 ns, SSD random read 16 us, SSD sequential 49 us, datacenter RTT 500 us, cross-continental 150 ms
- **Powers of 2** -- 2^10 ~= 1K, 2^20 ~= 1M, 2^30 ~= 1B, 2^40 ~= 1T
- **Common assumptions** -- 86,400 sec/day, replication factor 3, peak-to-average 2-3x typical
- **Throughput ballparks** -- Redis ~100k QPS, MySQL/Postgres ~1k-10k QPS reads, Kafka ~1 GB/s ingest, Nginx ~50k req/s static, S3 effectively unlimited

## Who it's for

- Software engineers preparing for system design interviews
- Architects doing capacity planning or writing design docs
- Anyone who needs quick back-of-the-envelope estimates

## Links

- [System Design Calculator](https://system-design-calculator.com/) -- the tool itself
- [Reference Cheatsheet](https://system-design-calculator.com/#reference) -- latency numbers, powers of 2, capacity ballparks