Skip to content

Glossary

How to use this sheet

Scan a group, then open the linked page for the terms you could not define aloud. Use these spellings in the room: the wrong word costs credibility the design then has to win back.

Tables

Estimation and performance

Term One line
QPS Requests per second at a boundary
Peak QPS Three times average, unless told otherwise
Back-of-envelope estimation Order-of-magnitude capacity math, done aloud
p50 / p95 / p99 Latency percentiles; p99 is the tail
DAU / MAU Daily and monthly active users
Working set The hot fraction worth caching
Nines Availability restated as yearly downtime

Networking, APIs and the edge

Term One line
DNS Name to address, cached by TTL
WebSocket One long-lived connection, both sides push
SSE Server-to-client stream over plain HTTP
Long polling Request held open awaiting an event
REST Resource nouns, HTTP verbs as actions
gRPC Binary RPC over HTTP/2, schema first
GraphQL One endpoint, client picks the shape
Idempotency key Client-supplied dedup key on a write
Cursor pagination Opaque position token, not a page number
Webhook The provider calls you back, signed
API gateway Edge policy: auth, routing, quotas
Layer 4 load balancer Routes connections by address and port
Layer 7 load balancer Routes requests by path or header

Caching and CDNs

Term One line
Cache-aside Caller checks, then populates the cache
Read-through The cache loads on a miss
Write-through Cache and store written together
Write-back Cache now, store flushed later
Write-around Store now, cache fills on read
Cache stampede Many callers rebuilding one expired entry
TTL Time to live before expiry
CDN Edge network serving bytes near users
Eviction policy How a full cache picks victims

Databases and storage engines

Term One line
OLTP Many small indexed transactional operations
OLAP Few large scans over columns
Denormalisation Duplicating data so reads avoid joins
Wide-column store Partition key groups, clustering key sorts
B-tree Balanced pages updated in place
LSM tree Memtable plus immutable files, merged later
SSTable Immutable sorted file of key-value pairs
WAL (write-ahead log) Durability log written before the change
Compaction Merging files, reclaiming space and tombstones

Replication, quorums and partitioning

Term One line
Leader / follower One writable replica, several read-only copies
Read replica A follower that offloads reads
Replication lag How far a follower trails
Synchronous replication Acknowledge only after a replica confirms
Leaderless replication Any replica takes writes, quorums decide
Failover Promoting a follower after leader death
Split brain Two nodes each believing they lead
Quorum (N, W, R) Replica counts where W plus R exceeds N
Last-write-wins Resolve by timestamp; silently loses writes
Sharding One dataset split across machines
Partition key The field choosing a row's shard
Consistent hashing Ring placement so few keys move
Virtual nodes Many ring positions per machine
Hot partition One shard taking most traffic
Hot key One key taking most traffic

Transactions and isolation

Term One line
ACID Atomic, consistent, isolated, durable
read committed No dirty reads; the usual default
repeatable read A row reads the same twice
serializable As if transactions ran sequentially
snapshot isolation Each transaction reads one consistent version
Write skew Concurrent writes break a cross-row rule
2PC Prepare then commit; blocks on coordinator loss
Saga Local transactions plus compensations
Transactional outbox Event written in the same transaction

Consistency models

Term One line
CAP theorem In a partition, consistency or availability
PACELC And when healthy, latency or consistency
Strong consistency Reads see the latest committed write
Eventual consistency Replicas converge once writes stop
Causal consistency Related writes are seen in order
Linearizable One global order respecting real time
Read-your-writes You see your own last write
Monotonic reads Reads never go backwards
CRDT A type whose concurrent merges converge

Messaging, streaming and feeds

Term One line
Message queue Work items consumed once, then removed
Publish/subscribe One event to every interested subscriber
Topic and partition The unit of ordering and parallelism
Consumer group Consumers sharing one topic's partitions
Consumer offset The position a consumer has committed
At-most-once May be lost, never duplicated
At-least-once Never lost, may be duplicated
Exactly-once (effectively-once) At-least-once plus an idempotent consumer
Dead-letter queue Where repeatedly failing messages land
Fan-out on write Push a post into follower feeds
Fan-out on read Merge followed authors at read time
MapReduce Map, shuffle, reduce over partitions

Consensus, coordination and time

Term One line
Consensus Agreement on one value despite failures
Raft Consensus as a replicated log
Leader election Choosing the node allowed to coordinate
Lease A lock with an expiry
Fencing token A rising number stopping a stale holder
Lamport timestamp A counter giving order, not causality
Vector clock Per-node counters that detect concurrency
Hybrid logical clock Physical time plus a counter

Probabilistic structures, limits and geography

Term One line
Bloom filter Maybe present, definitely absent, few bits
Count-Min Sketch Approximate frequencies for heavy hitters
HyperLogLog Approximate distinct counts in kilobytes
Token bucket Tokens refill; bursts up to the cap
Leaky bucket Drains at a fixed rate
Fixed window counter Count per window; doubles at boundaries
Sliding window log Exact and expensive: keep every timestamp
Sliding window counter Two windows blended; the production choice
Geohash Coordinates interleaved into a string prefix

Resilience, observability and delivery

Term One line
Circuit breaker Stop calling a failing dependency
Bulkhead Separate pools so failure stays local
Backpressure Telling the producer to slow down
Load shedding Reject low-value work under stress
Exponential backoff Doubling the wait between retries
Graceful degradation A worse answer rather than none
SLI The measured indicator
SLO The internal target for it
SLA The contract, with money attached
Error budget The failure an SLO permits
Distributed tracing Spans stitched into one request's journey
Blue-green deployment Two environments, traffic switched at once
Canary release New version on a small traffic share
Feature flag Release separated from deploy

Architecture, storage systems and security

Term One line
Monolith One deployable; the right default first
Microservice One service per hard boundary
CQRS Separate write model from read model
Event sourcing Store events, derive the state
Horizontal scaling More machines, not bigger ones
Stateless service No client state; any replica serves
Object storage Flat keyed blobs, cheap and unbounded
Inverted index Term to document list, behind search
OAuth 2.0 Delegated authorisation by token
JWT Signed self-contained token; revocation is hard
Allowlist / denylist Explicitly permitted, or explicitly refused

Object-oriented design

Term One line
Single responsibility One reason to change per class
Open/closed Extend by adding, not by editing
Liskov substitution A subtype keeps the base's promises
Interface segregation Many small interfaces, not one fat
Dependency inversion Depend on abstractions, wire at the root
DRY One home per reason to change
KISS The simplest thing that works
YAGNI Build it when a requirement asks
Law of Demeter Talk to neighbours, not their neighbours
GRASP Nine answers to which class owns
Cohesion How related one class's contents are
Coupling Knowledge one class needs of another
Value object Immutable, compared by value
Entity Mutable, identified by id, guards transitions
Protocol Structural interface: shape, not inheritance
Composition over inheritance Prefer has-a to is-a
snake_case / PascalCase Functions and variables, versus classes

Contracts, UML and design smells

Term One line
Invariant True before and after every call
Multiplicity The number on a relation
Composition (UML) The part dies with the whole
Aggregation (UML) The part outlives the whole
Anemic model Data-only classes, logic in a service
God object A class whose name needs "and"
Pattern-itis Patterns without an axis of change

Concurrency and testing in LLD

Term One line
GIL Protects the interpreter, not your invariants
Race condition Correctness depending on thread timing
Deadlock Two holders waiting on each other
Reentrant lock The same thread may reacquire it
Condition variable Wait for a predicate without spinning
Lock ordering Multiple locks taken in one order
Optimistic concurrency control Check a version on write, retry
Fake A simple working double for tests
Mock A double asserting on calls
Fake clock Injected time, so tests never sleep

Memory hooks

  • Say the canonical word: leader and follower, allowlist and denylist, p99, QPS, effectively-once.
  • Effectively-once = at-least-once + idempotent consumer. There is no other kind.
  • CAP applies only during a partition; PACELC covers the rest of the year.
  • Availability is a duration, not a count of nines. Convert before you speak.
  • Fan-out on write pays at publish; fan-out on read pays at every view.

Interview tip

Define a term in five words the moment you use it: "sloppy quorum, meaning any live node may accept the write". It proves you are not repeating a phrase, and gives the interviewer a cheap place to correct you.

Common mistake

Reaching for an approximate word: "eventually consistent" with no staleness window, "exactly-once" in a system full of retries, "linearizable" for anything strong-ish. Interviewers probe whichever term you chose, so use the loose one only when the precise one is ready.