Grow retry intervals exponentially and add randomization so clients don't synchronize their retries.

Caller sends a unique key with each request; server dedupes on it so retries don't double-charge.

If the first request hasn't returned by some threshold (p95, the 95th percentile latency), fire a second one and take whichever finishes first.

Bound the total time spent retrying, not the number of attempts. Each retry costs from the same budget.

Track failures from a dependency; once they exceed a threshold, open the circuit and fail fast for a cool-down period.

When a non-critical dependency fails, return a useful partial response instead of erroring the whole request.

Probabilistic set membership in tiny memory. No false negatives; tunable false-positive rate.

Estimate cardinality (unique count) of a massive set using a few KB of memory and a small error margin.

Estimate frequency of items in a stream using sublinear memory; never underestimates.

Sample k items uniformly at random from a stream of unknown (and unboundedly large) length.

64-bit unique IDs: [timestamp][machine-id][sequence]. Time-ordered, distributed, no central coordinator.

Timestamp-prefixed UUID — sortable, monotonic, still 128-bit and globally unique.

Each node maintains a counter; events carry a vector of counters that captures partial causal ordering.

Single counter per node, advanced to max(local, received) + 1 on every message. Gives total ordering of causally related events.

A dedicated service hands out strictly increasing 64-bit IDs. Simpler than Snowflake when you don't need offline generation.

When a downstream component is slow, signal upstream to slow down (don't just buffer and OOM).

Coalesce many small operations into one large one to amortize fixed per-request overhead.

Wait until a flurry of events stops for N ms, then act once. Drops everything in between.

Emit at most once per N ms regardless of how often it's called. Unlike debounce, never goes silent.

Bucket refills at rate R; each request takes one token. Allows controlled bursts up to bucket size.

Requests enter a queue, processed at fixed rate. Smooths out bursts entirely — no spike ever reaches downstream.

Grant time-bounded exclusive ownership. Holder must renew before expiry; if it dies, the lease auto-releases.

Write to W replicas, read from R replicas, with W + R > N. Guarantees any read sees at least one of the writes.

On a quorum read, if replicas disagree, write the freshest version back to the stale ones in the background.

Background process that compares replicas using a Merkle tree of data and ships only the differing ranges.

Periodic 'I'm alive' signal. Absence of N consecutive heartbeats means the peer is presumed dead.

Read a value with its version, send update conditional on version unchanged. Server rejects if someone else wrote in the meantime.

Mutual-exclusion primitive: at most one thread holds the lock at a time, serializing access to a critical section.

Allow many concurrent readers OR one exclusive writer, but never both — boosts throughput on read-heavy state.

Hardware-level atomic instruction: write a new value only if the current value matches expected; otherwise retry.

Wait on a predicate while holding a lock; another thread signals when the predicate may now be true, atomically releasing and re-acquiring the lock.

Counter with atomic acquire/release: lets at most N permits be held simultaneously. Generalizes the mutex (N=1).

Pre-allocated worker threads pull tasks from a shared queue, so you pay thread-creation cost once and bound concurrency.

Producers offer work to a fixed-capacity queue; consumers drain it. Bound provides natural backpressure when consumers fall behind.

Per-thread variable: every thread sees its own copy, eliminating sharing and therefore eliminating the need to synchronize.

Never mutate a shared object; on write, copy it and atomically swap the reference. Readers are entirely lock-free.

Represent an in-flight computation as a value you can compose, chain, and await — no manual callback threading.

Leader-based consensus protocol: one elected leader replicates an append-only log to followers; entries commit once a majority quorum acknowledges.

Tune per-operation consistency by requiring W replicas to ack writes and R replicas to answer reads. If R + W > N, every read overlaps the latest write.

Each replica tags writes with a per-node counter map. Comparing two versions reveals causal order, concurrency, or strict dominance.

Each node periodically picks a random peer and exchanges state. Information spreads epidemically in O(log n) rounds with bounded per-node bandwidth.

A would-be leader acquires a time-bounded lease in a consensus store; it must renew before expiry or lose leadership. Bounds split-brain to one lease window.

Replicas build a tree of hashes over their key ranges; comparing root then children lets them find divergent ranges in O(log n) hops instead of full scans.

Data types whose merge function is commutative, associative, and idempotent, so any two replicas converge to the same value without coordination.

Coordinator asks all participants to PREPARE; if all vote yes it sends COMMIT, otherwise ABORT. Blocks if the coordinator crashes between phases.

If a target replica is down, a healthy node stores the write locally with a 'hint' and forwards it once the target recovers. Keeps write availability high.

Replicas arranged in a chain: writes enter at the head, flow through every link, commit at the tail. Reads served by tail give linearizable results with simple logic.

Balanced, fan-out heavy tree where leaves hold sorted keys (and in B+trees, are linked for range scans). Lookup, insert, delete in O(log n).

Buffer writes in an in-memory memtable, flush sorted runs (SSTables) to disk, then merge them in background compaction passes.

Hash table over a column; O(1) average point lookup, but no order, so no range scans or ORDER BY.

Add the columns you SELECT into the index so the query plan never visits the heap. The index alone covers the read.

Each write produces a new row version tagged with the transaction id; readers see the version visible to their snapshot. Readers never block writers, writers never block readers.

Append every change to a sequential log and fsync before touching the data pages. On crash, replay the log to recover committed work.

Persist the result of a query as a real table; refresh on schedule, on demand, or incrementally as base tables change.

Attach a small probabilistic filter to each SSTable. A point lookup checks the filter first and skips the file if it says 'definitely not present'.

Algorithms that decide how fast TCP (Transmission Control Protocol) sends. Loss-based (Reno, Cubic) treat packet loss as congestion; model-based (BBR) measures bottleneck bandwidth and round-trip time (RTT) directly.

TLS (Transport Layer Security) 1.2 needs 2 round trips before app data flows. TLS 1.3 collapses that to 1 round trip (1-RTT) for new sessions and 0 round trips (0-RTT) for resumed ones using pre-shared keys (PSK).

Many concurrent streams over a single TCP (Transmission Control Protocol) connection, each with its own flow control. Fixes HTTP (Hypertext Transfer Protocol) 1.1 head-of-line blocking at the HTTP layer but not at TCP.

HTTP (Hypertext Transfer Protocol) 3 runs over QUIC, a UDP (User Datagram Protocol) based transport with built-in TLS (Transport Layer Security) 1.3, per-stream flow control, and connection migration across IP changes.

Reuse TCP (Transmission Control Protocol) and TLS (Transport Layer Security) connections across requests instead of opening a new one each time. Avoids the 3-way handshake plus TLS handshake on every call.

Nagle's algorithm coalesces small writes to reduce tinygrams. Combined with delayed-ACK on the receiver, it can stall small request/response pairs for ~40ms waiting for the next ack.

Readiness-based (epoll, kqueue) or completion-based (io_uring, IOCP) APIs that let one thread watch tens of thousands of file descriptors without a thread per connection.

Move bytes from disk to socket without copying through user space. The kernel hands page-cache pages directly to the NIC's DMA engine.