Terms & Acronyms — One-Stop Glossary
Why this page exists
Most guides throw TPS, NIC, p99 at you and assume you know them — so the
real idea never lands. This is the one-stop decoder for the vocabulary used across system design, performance,
and infrastructure. It deliberately includes standard industry terms you’ll meet in interviews even if they don’t
appear elsewhere in this guide. Skim it once; return to it whenever a term trips you up.
Rate & throughput — the “…PS” family (where most confusion lives)
| Term | Means | Note |
|---|---|---|
| QPS | Queries Per Second | Read-ish requests hitting a service |
| TPS | Transactions Per Second | Heavier than a query — a write + durability (commit) |
| RPS | Requests Per Second | Generic HTTP requests; often used like QPS |
| IOPS | I/O Operations Per Second | Disk/SSD read-write ops (SSD ~10K–100K) |
| Throughput | Work done per unit time | req/s or MB/s |
| Bandwidth | Max data rate of a link | The ceiling (e.g. 1 Gbps), not the actual rate |
| Goodput | Useful throughput | Throughput minus retransmits/overhead |
Latency — time for one operation
| Term | Means |
|---|---|
| Latency | Time for a single operation (ms). Throughput = how many; latency = how fast each. |
| RTT | Round-Trip Time — request out + response back (same-DC ~0.5 ms, cross-continent ~150 ms) |
| p50 / p95 / p99 | Percentile latency. p99 = 99% of requests are faster than this — the “tail” slow users feel. Design for p99, not the average. |
| Tail latency | The slow end of the distribution (p99+); dominates user-perceived slowness |
| Jitter | Variation in latency between requests |
| HOL blocking | Head-of-line blocking — one stuck request delays those queued behind it |
Hardware & network
| Term | Means |
|---|---|
| NIC | Network Interface Card — the machine’s network port; its speed caps bandwidth (1/10/25 Gbps) |
| vCPU / core | A unit of parallel compute; a thread runs on a core |
| RAM | Main memory — ~100 ns access, volatile |
| Cache (L1/L2/L3) | Tiny ultra-fast CPU memory (~1–10 ns) |
| SSD vs HDD | SSD ~500 MB/s seq, ~100 µs random; HDD seek ~10 ms |
| ⚠️ Gbps vs GB/s | The #1 estimation trap. Network = bits; storage = bytes. 1 Gbps = 125 MB/s — divide by 8. |
Protocols & web
| TCP / UDP | Reliable/ordered vs fast/lossy transport |
| IP | Network-layer host addressing (see Networking Fundamentals) |
| HTTP/1.1 · 2 · 3 | Web protocol generations; HTTP/3 runs on QUIC (UDP-based) |
| TLS / mTLS | Transport encryption; mTLS = both sides present certificates |
| REST / gRPC / GraphQL | API styles (see Building Blocks) |
| WebSocket / SSE | Full-duplex / server-push real-time channels |
| DNS / CDN | Name resolution / edge content delivery |
Data & consistency
| ACID / BASE | Strong transactional vs eventually-consistent guarantees |
| CAP / PACELC | Consistency-availability-partition trade-off; PACELC adds the latency dimension |
| Quorum (N/R/W) | Replicas / read-set / write-set; R + W > N ⇒ strong consistency |
| TTL | Time To Live — expiry for cached/stored data |
| WAL | Write-Ahead Log — durability + crash recovery |
| CDC | Change Data Capture — stream a DB’s changes downstream |
| MVCC | Multi-Version Concurrency Control — readers don’t block writers |
| Idempotency | Doing it twice = same result as once (safe retries) |
| FK / PK | Foreign key / primary key |
| UUID / ULID | 128-bit unique IDs (ULID is time-sortable) |
Reliability & operations
| SLA / SLO / SLI | Agreement (the promise) / Objective (internal target) / Indicator (measured metric) |
| Availability (“nines”) | 99.9% ≈ 8.7 h down/yr · 99.99% ≈ 52 min · 99.999% ≈ 5 min |
| RPO / RTO | Disaster recovery: how much data you can lose / how fast you must recover |
| MTBF / MTTR | Mean time between failures / mean time to recovery |
| Error budget | Allowed unreliability (1 − SLO); spend it on shipping speed |
| Circuit breaker / Backpressure | Stop calling a failing dependency / push load back to slow producers |
Scaling & architecture
| Horizontal / Vertical scaling | Add more machines / make one machine bigger |
| Sharding / Partitioning | Split data across nodes by a key |
| Consistent hashing | Minimal-rebalance key→node mapping |
| LB / API Gateway / BFF | Load balancer / single entry point / backend-for-frontend |
| CQRS / Saga / Outbox / DLQ | Read-write split / distributed transaction / reliable publish / dead-letter queue |
| Object / Block / File storage | S3-style blobs / raw volumes / filesystems |
| B-tree / LSM-tree | Read-optimized vs write-optimized storage engines |
Formulas are standard/public-domain engineering math. Approach and reference-table format adapted from the System Design Primer (CC BY 4.0), Jeff Dean’s latency numbers, the DesignGurus capacity-estimation guide, and Little’s Law.
🤖 Don't fully get this? Learn it with Claude
Stuck on Terms & Acronyms — One-Stop Glossary? Open Claude, copy a block below, and it'll teach you this exact concept — visually and interactively.
🎨 Explain it visually
Build the mental picture, not memorization.
I just read a lesson on **Terms & Acronyms — One-Stop Glossary** (System Design) and want to truly understand it. Explain Terms & Acronyms — One-Stop Glossary from first principles using ONE vivid real-world analogy and a visual mental model — draw it as ASCII art or a clear step-by-step diagram — with a concrete example using real numbers. Then ask me one question to check I got the mental picture, and wait for my reply. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.
🤔 Walk me through it (interactive)
Socratic — adapts to where you're stuck.
Teach me **Terms & Acronyms — One-Stop Glossary** interactively. Ask me ONE guiding question at a time, wait for my answer, and adapt to my confusion — build the idea with me step by step instead of explaining it all at once. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.
🧪 Quiz me & fix my gaps
Active recall exposes what you missed.
Quiz me on **Terms & Acronyms — One-Stop Glossary** with 5 questions, easy to tricky, ONE at a time. Tell me if each answer is right; at the end, explain clearly what I got wrong and why. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.
🧠 Make it stick
Intuition + hook + flashcards for long-term memory.
Help me remember **Terms & Acronyms — One-Stop Glossary** for the long term: give the one-sentence intuition, a memorable hook/mnemonic, a tiny worked example, and 3 active-recall flashcards (Q -> A). If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.