Can I see it myself?

Put your own code on the roofline

Measure this machine's memory and compute ceilings, then place a scan, a filter and a hash aggregation on its roofline.

Reproduce incast on a laptop

One receiver asks N senders for 32 KB at once, N from 1 to 500, with synchronized and jittered replies: p50, p99, p999 on loopback.

Fit a USL curve to something real

N processes each scanning their own array (memory-bandwidth-bound): fit the Universal Scalability Law at N ≤ 8 and test the prediction beyond.

Bufferbloat: a bigger buffer buys latency, not throughput

A producer 20% faster than its consumer, with queues from 100 to 100,000: throughput stays put, latency grows with the queue.

What an overflowing buffer loses

A keyed stream overloads a bounded buffer under drop-newest, drop-oldest and drop-oldest per key: count the records dropped and the entities left with a wrong value.

Batch size: find the knee

Insert 200,000 rows into SQLite with one commit per batch, then bound trickle-traffic latency with a size-or-age rule.

Token bucket versus fixed window

Two bursts straddling a one-second boundary against a fixed window, two token buckets and a sliding window.

Measure key skew and the effect of salting

Partition 1,000,000 events by seller, by order and by salted seller, when one seller owns 40% of them.

How many keys move when N changes? Modulo vs. ring vs. rendezvous

Add an eleventh node: how many of 100,000 keys move under modulo hashing, a ring with 1 or 128 virtual nodes, and rendezvous hashing.

Break per-key order in a real Kafka topic, then repair it

Per-key order in Kafka, broken three ways (a worker pool, lost acks without idempotence, growing the topic) and repaired twice.

A DLQ that does not become an outage amplifier

Write a small consumer with a retry-then-DLQ policy.

Choose N by measurement

Measure one consumer, derive the partition count, then compare N and 2N partitions for recovery time and files per hour.

What a rebalance repeats

Redeploy one consumer of a 12-member group on a 24-partition topic, many times: count what eager, cooperative and static membership process twice.

The length-prefix attack and the maximum frame size

A server that trusts a 4-byte length header, a header claiming 4 GB, and one wrong length in the middle of a stream.

Batch size is a compression parameter

Compress 100,000 small JSON events in batches of 1 to 10,000, then with a trained dictionary.

Compress or not: the rate comparison

compress + transfer + decompress against sending raw, for five codecs and three link speeds.

Stale pooled connections: find out what your pool does

Exhaust a pool of 2, kill a proxy silently under a pooled connection, and read your HTTP library's defaults.

Nagle plus delayed ACK: reproduce the 40 ms cliff

Two small writes and a short reply: Nagle on the sender and delayed ACK on the receiver add about 40 ms per call.

Dedup window versus replay

A 60-second dedup window against a replay five minutes later, then idempotency by replacing the partition.

Reconciliation count and duplicate-rate metric

Count records per hour at source and sink, then plant a bug that swallows 1% of writes: errors stay at zero, the count gap does not.

Clustering payoff: sorted versus random files

20 million rows as 20 Parquet files, random and sorted by (depot_id, scan_time): files a one-depot query must open, then after one unsorted append.

The composite-key rule (`C_a ≤ U`)

20 files sorted by (depot_id, scan_time) and by (user_id, scan_time): files a one-day query must open, alone and with a depot.

Z-order floor

A million 2-D points in 4,096 units: sorted on dimension 1, Z-ordered, and random; units a thin query on each dimension touches, and a 50/50 mix.

Queue depth and the 0.7% reader

Random 4 KB reads from a 2 GB file with 1 to 128 requests in flight, page cache bypassed: IOPS against queue depth; then mmap.

Group commit and the square-root rule

Append 100-byte records with a flush after every 1, 10 and 100; then a timer batcher at λ = 2,000/s for waits W from 0.5 to 16 ms against W* = √(2·fsync/λ).

What does fsync really cost on your machine?

Time 200-byte appends with no sync, with fsync, and on macOS with F_FULLFSYNC: the durability tax of your drive.

Checkpoint interval versus WAL volume (Postgres)

Run pgbench for 120 s with checkpoints every 30 s and every 15 min, then without full-page writes; compare WAL bytes per transaction.

Restore test and time-to-restore

Back up a 1 GB PostgreSQL database with WAL archiving, drop a table, restore to just before the drop, time it; then restore without the WAL.

A checksum that proves identity

A toy block store with checksums next to the data and checksums in an index: which one catches a misdirected write and a lost write?

Monkey-style filter allocation

Split one Bloom-filter memory budget across LSM levels equally or Monkey-style, count wasted I/Os per million missing-key lookups.

Sparse index granule size

Index a sorted file of 100 million records every G records and time point lookups for G from 64 to 65,536.

Sliding maximum: naive, deque and panes

Compute a sliding maximum over a 10,000-value window naively, with a monotonic deque, and with panes; then feed the deque its best and worst shapes.

Top-k with a bounded heap versus a full sort

Find the top 10 of 20 million numbers with sort | head and with a bounded heap; compare time and peak memory, then read DuckDB's plan.

Bloom filter: measure the false-positive curve and the cache cost

Measure a Bloom filter's false-positive rate at 5 to 20 bits per key against the formula, then time lookups in a 10 MB, a 1 GB and a blocked 1 GB filter.

Count-Min Sketch: head versus tail

Count a Zipf stream of 10 million events with a Count-Min sketch, compare head and tail errors, then find heavy hitters with Misra-Gries and Space-Saving.

HyperLogLog: error, merge and the intersection trap

Check HyperLogLog's error over 20 runs, merge two sketches, then estimate a 1% intersection with HLL and with a Theta sketch.

Do not average percentiles

Compute the p99 of 100 shards by averaging shard p99s and by merging KLL, t-digest and REQ sketches, against the exact pooled p99.

Roaring versus plain bitmap versus sorted array

Size sets of row IDs at five densities as a plain bitmap, a sorted array and a Roaring bitmap, then time a 1% intersection in each.

Elias-Fano and the posting-list size

Store a million sorted doc IDs as int32, delta + varint and Elias-Fano; compare size and random-access time.

False sharing: measure the 64-byte penalty

Eight threads increment their own counters: packed in one line, padded to 64 and 128 bytes, and counted locally.

SPSC ring buffer: head and tail on one line, then on two

Move 100 million items through a single-producer single-consumer ring with head and tail on one line, on separate lines, and with batched publishing.

Persistent tree: measure the cost of path copying

Insert a million keys into a mutable and a persistent binary tree; compare time and memory, hold a snapshot, count shared nodes.

Reader-writer lock against plain mutex on a read-heavy workload

99% reads and 1% writes from 1 to 16 threads under a mutex, a reader-writer lock and an atomic snapshot pointer.

Build a pruning cascade and count rows touched

Prune 1,000 point-in-range queries over 10 million rows through a zone map, a Bloom filter and a sparse index; then shuffle the rows.

Varint and zigzag: where the bet wins and loses

Bytes per value under varint and zigzag + varint for small counts, IDs, random 64-bit values and small signed numbers.

Row order versus codec

Write 2 million rows to Parquet shuffled and sorted under NONE, SNAPPY and ZSTD; compare sizes and the depot column's row-group statistics.

One outlier sets the width

Bit-pack a block of 128 values, add one outlier, then patch it out with PFOR.

Encoding by hand: dictionary, RLE and delta

A 10-million-value country column and a sorted timestamp column: dictionary, RLE before and after sorting, delta, and gzip, computed by hand.

Are your floats decimals in disguise?

A million latitude-like doubles with six decimals: zlib on the raw bytes against scaling to integers and frame-of-reference.

Block size, ratio and point-lookup cost

Compress 200,000 JSON rows in blocks from 1 KB to 1 MB; compare ratio and the cost of decoding one block for a point lookup.

Does a trained dictionary rescue small messages?

Compress 100-byte JSON messages one at a time with and without a trained zstd dictionary, then decode with the wrong one.

Zone maps and clustering

50 million timestamped rows in Parquet, random and sorted: row groups a one-hour query must read.

Inverted index intersection

Intersect posting lists for a common and a rare term over a million documents: query order, smallest first, and skips.

Choose nlist for IVF

IVF over a million random 128-dimensional vectors: queries per second and recall@10 for nlist 100 to 16,000 and nprobe 1 to 32.

One old snapshot pins the version space

Two minutes of random updates on a million-row PostgreSQL table, without and with an old Repeatable Read snapshot open: size and dead tuples.

Pessimistic versus optimistic crossover

16 workers doing read-modify-write on a PostgreSQL counter table of K rows, with SELECT FOR UPDATE and with a version column: throughput and goodput from K = 1,000,000 to 1.

Write skew under snapshot isolation, and its fix

Two on-call agents each check that two are on shift and each go off shift: REPEATABLE READ against SERIALIZABLE; then 50 clients and the retry rate.

The idempotency key: the unknown outcome made harmless

A top-up whose acknowledgment is lost, retried naively and with an idempotency key in SQLite; then a replay after the key has expired.

Savepoint cliff in Postgres (more than 64 subtransactions)

A PostgreSQL transaction holding 0 to 200 subtransactions open while pgbench reads the same rows: read throughput across the 64-subtransaction cache.

Contended compare-and-swap: n²T/2 and the value of jitter

n writers each need one successful conditional write on a shared pointer: total time and wasted attempts with immediate retry and with jittered backoff.

Availability of unanimity: 0.999ⁿ versus a majority

Atomic commit needs every participant; consensus needs a majority: a^n against the binomial majority, then 10 million simulated rounds with and without rack failures.

Reproduce the lost update at Read Committed, then fix it three ways

Lose an update under Read Committed in PostgreSQL, then fix it four ways.

Same name, different promise: compare engines

One phantom test at the level PostgreSQL and MySQL both call Repeatable Read, with different results.

Write skew under Repeatable Read, and the two cures

Two transactions each check a total, then withdraw from different accounts: write skew under Repeatable Read, and the two cures.

Read-your-writes with a replica, and a lost token

Write on a PostgreSQL primary, read from a lagging replica, then carry a log-position token, then lose it.

Anomaly rate equals window times rate

Stale reads from a lagging replica against λ × W, for three lags, then reads routed to the primary after a write.

LWW versus a G-counter under clock skew

Three replicas, one clock 3 s ahead, 1,000 increments: last-writer-wins and max lose them; a G-counter keeps all.

R + W > N is not recency

A toy N = 3 register: a failed W = 2 write leaves reads with R = 2 going back and forth.

Count I-confluence in your own schema

Classify every constraint of a schema as invariant-confluent or not, and price the escrow for its bounds.

Run an Elle-style check on your own database

A list-append workload against PostgreSQL at three isolation levels, with the dependency graph rebuilt and searched for cycles.

Join algorithms and the memory threshold

A 20-million-row probe joined to a 5-million-row build side with a payload in DuckDB, under memory limits from 4 GB to 100 MB, and at 1 and 8 threads.

As-of join versus range join

The price at order time for 1,000 products × 1,000 price changes: a range join with ROW_NUMBER against DuckDB's ASOF JOIN.

When does partial aggregation pay?

Local pre-aggregation of 100,000 rows per partition for G from 100 to 4 million groups: measured reduction against N/(P·G), and its cost.

Sketches versus sampling for COUNT DISTINCT

Distinct users in 20 million events: exact, HyperLogLog, and "count distinct in a 1% sample × 100"; then the same sample for a SUM.

Float summation is not associative

One million doubles of very different magnitudes summed in five random orders with a plain loop, against math.fsum.

The sort that is not an I/O problem: count the passes

DuckDB sorts 20 million rows (about 2 GB) under a 500 MB memory limit: temp files, wall and CPU time, random and pre-sorted input, and the one-pass capacity M²/B.

Normalized keys and sorting a pointer array

Sort 300,000 three-column rows with a typed comparison and with normalized byte keys; then sort prefix + index pairs.

Digest collisions and Bloom-filter data loss

The birthday formula with 32-bit digests; then a Bloom filter used as a dedup over a million distinct keys, and as a negative oracle in front of an exact set.

A partition with no statistics

Load a new day into a partitioned PostgreSQL table and compare the plan before and after ANALYZE on that partition alone.

Cross the dynamic-programming cliff

Plan joins of 8 to 16 tables in a chain and a star with PostgreSQL's exhaustive search and with GEQO; count distinct plans.

Four pairs of equal queries

NOT IN against NOT EXISTS with a NULL, a function on a partition key against a range, and a CTE materialized or not, in PostgreSQL.

Min/max skipping on sorted versus unsorted data

10 million store_ids in Parquet, random and sorted: how many of 100 row groups a filter must read, and what one outlier does.

Pushdown and projection: count the bytes

DuckDB on Parquet: a filter on sorted and random files, all columns against one, and a filter wrapped in an expression.

Top-N heap against full sort

The top 100 of 20 million numbers with a sort and with a heap; then a PostgreSQL LIMIT that makes the plan worse.

Bloom filter size and false-positive rate

Bloom filters for a million keys at 5, 10 and 15 bits per key: false-positive rate and size.

Late materialization crossover

Filter a 100-million-element array with a boolean mask and with a position list, across selectivities, and find where gathering loses.

Parameter sniffing in PostgreSQL

A prepared statement on a 95%/0.002% skewed column: custom plans, generic plans, and when PostgreSQL switches between them.

Compute a compilation break-even

Turn "compilation has a break-even data volume" into a measured number.

Per-row UDF versus vectorized UDF

Score 5 million rows with x * 0.3 + 2.0 per row and vectorized in blocks of 100 to 1,000,000; and the time to read and write the data.

Whole-query restart against task retry

Check that expected whole-query attempts grow like e^(nTλ).

The Zipf ceiling on data-parallel speedup

Turn "the largest partition is your serial fraction" into a number.

Triage plot, salting and the join product

Classify three kinds of long tail, then fix skew by salting, and see that join skew multiplies.

Many small reads against few large reads: the transfer floor

Measure the minimum efficient transfer size on your own disk, then compute a shuffle width ceiling from it.

When does shuffle compression pay? And a non-deterministic partition function

Measure codec throughput and ratio on shuffle-like data, then apply C > BW · r/(r−1).

LRU, random and Clock on a cyclic loop

LRU, random and Clock replaying a loop over 100 pages for pools of 1 to 100 frames; then a one-time scan against a hot set under LRU, 2Q and a scan ring.

Scan resistance in a real database (PostgreSQL)

PostgreSQL with a 128 MB buffer pool: a hot table's pages after a sequential scan of a 1 GB table, and after reading the same table through an index.

Grant quantization: count the passes

The external sort pass count ⌈log_(M/B − 1)(N/M)⌉ for 1 TB across memory grants; then PostgreSQL sorting 5 million rows from work_mem 64 kB to 1 GB.

The spill cliff: 5% spilled, how much slower?

Measure memory and disk bandwidth, then spill 0%, 5% and 20% of an 800 MB array to a file and back: the slowdown against (1 − f) + 2·f·r.

Sort versus hash under a hot key

50 million rows with 30% on one key under a 500 MB DuckDB limit: SUM/COUNT against median by key, and a grace partitioner's largest partition under 5 hash seeds.

Queueing on the spill device

Rate-limited sequential writers sharing one SSD at 20% to 100% of its measured throughput: completion latency against S/(1 − ρ).

Negative cache and Bloom filter

Measure the effect of absent-key lookups and the false-positive rate of a Bloom filter.

The race between a reader and a writer: update versus delete

Use two threads and a dictionary as the "cache" plus a second dictionary as the "store".

Stampede with and without protection

Write a small Python program with a fake "database" function that sleeps 2 seconds and counts how many times it is called.

Scan resistance: LRU against an admission filter

Generate a Zipf-distributed request stream (alpha = 1) over 100,000 keys with numpy.random.zipf or a precomputed cumulative table, 2 million requests, cache size C = 5,000.

Fencing tokens versus a paused leader (about 30 minutes)

Claim to test: a lease alone leaks at the boundary, and a fence checked by the resource closes the gap (What coordination forbids, item 3).

Escrow removes coordination

Measure the message count of a global budget with and without escrow ([Coordination avoidance, which is where this article should end](/mechanisms/coordination/how-it-works/deciding-without-observing/coordination-avoidance)).

Fan-out tail and power-of-two-choices (about 45 minutes)

Claim to test: at N = 100 and per-shard p99, about 63% of requests contain a p99 event, and two random choices beat greedy choice on stale load information (see Scatter-gather and Service discovery).

Hedging: when it helps and when it does not (about 40 minutes)

Claim to test: hedging at p95 turns a 1-in-20 slow tail into about 1-in-400 if slowness is attempt-local, and does nothing if it is request-local (see Hedging).

Replay determinism check

An aggregation run twice over the same events, with now() and a mutable lookup, then with event time and a versioned lookup: compare output hashes.

Duplicates versus an idempotency key

A small payment service, 1,000 charges and 20% lost replies: a new key per attempt, an intent key with a stored outcome, and suppression with an error.

Dedup window size and the Bloom filter trap

The memory of exact deduplication for an hour and a week at 100,000 keys/s, then a Bloom filter alone and in front of an exact set.

Idempotent sink with a conditional insert

Redelivered batches into SQLite: a plain insert duplicates, a keyed conditional insert does not, and check-then-insert races.

Commit ordering and the offset in the sink

A consumer adds 1..10,000 to a total and crashes 20 times: position saved before processing, after, and in the same transaction.

Auto-commit versus commit-after-process

Kafka auto-commit against commit-after-process, each killed once mid-run: silent loss against a bounded number of duplicates.

Bulkheads: one slow dependency, one shared pool

One pool of 10 threads shared by a dependency that hangs and one that is fast, against two pools of 5.

Gray failure: dead node versus slow node

A 200-node scatter-gather query with one dead node, one slow node, peer-relative ejection, an all-slow fleet and an eviction cap.

Autoscaler flapping and the effect of dead time

An autoscaler targeting 60% utilisation with a provisioning delay of 0, 2 and 5 minutes, then with hysteresis and slow scale-down.

Recovery time arithmetic and replay storms

Stop a queue for 60 s at ρ = 0.5, 0.8 and 0.9, time the drain, watch the catch-up overload a downstream stage, then drop stale items.

A circuit breaker that protects the caller

A dependency that hangs for 30 s: without a breaker every thread blocks; with one the service answers fast and recovers.

The power of two choices

100,000 tasks onto 100,000 machines: one random choice, the lesser loaded of two, and of three. The maximum load over five seeds.

Throughput versus goodput past the knee

A service of 100/s receives 150/s and clients give up after 2 s: unbounded queue, bounded queue, and bounded queue with a deadline check.

The multiplexing dividend and its collapse under correlation

16 tenants with partly correlated demand: the 99th percentile of the summed demand against the sum of 99th percentiles, for ρ from 0 to 1.

An autoscaler that arrives too late

A reactive autoscaler with a 240-second delay against two 90-second bursts: unserved demand and idle capacity for 0% to 200% headroom.

Simulate the spot gang

A job that needs 100 spot nodes at once: its hourly survival, and how checkpointing sets its completion time.

Test the commitment-sizing rule

Find the commitment level that minimises a year of cost under skewed demand, and how a falling price moves it.

Dry-run before you run

Estimate a query's scanned bytes from Parquet metadata four ways: every column, two columns, a partition filter, an uncorrelated filter.

Trigger mode versus sink

A window fires twice (3,100, then 3,260) in accumulating or discarding mode, into an overwriting sink or an additive counter.

Bitemporal table in SQLite or Postgres

A rate table with valid time and transaction time in SQLite: a correction, two as-of questions, and the same history with one updated_at column.

Event time versus availability time

Features with available_time = valid_time + 9 h: how many events get a different value when joined on availability, and what that does to a model.

Leakage inflates the score (naive join versus as-of join)

20,000 deliveries with a drifting courier speed feature: a naive join on the latest feature value against an as-of join, scored offline and on a later period.

The daylight-saving key bug

02:30 on 26 October 2025 happens twice in Berlin: two instants, one local text. Then month arithmetic in two orders.

Replay determinism test

A transformation that reads current_timestamp, run twice and "tomorrow"; then with a run_date parameter. Output hashes compared.

Aligned versus unaligned checkpoints under backpressure (optional, needs a local stream engine)

A model of barrier checkpoints behind a bounded buffer and a slowing sink: duration and size, aligned against unaligned.

Replay determinism

An exactly-once loop with checkpoints, crashed at random and restarted 50 times: a pure computation and one that reads random.random(); then an upsert sink.

Aliasing in a polling pipeline

Poll a fast-changing row every few seconds and count how many of its changes, and its delete, the poller ever sees.

What query-based CDC misses

A poller on updated_at against three changes it cannot see: intermediate updates, a delete, and a slow commit.

Sum versus max under deletes

Maintain SUM and MAX per group under inserts and deletes, and count the rescans and memory each needs.

Inject loss, then catch it

Drop 0.1% of the changes in a toy CDC pipeline, catch it with a count + checksum, and crash it under three cursor-commit orders.

Retention window versus storage

A model of a table format: 10% rewritten daily for 10 days, storage after expiry and vacuum for 1-, 3- and 7-day windows; then a long query after a short vacuum.

Find the square-root interval by simulation

A read penalty that grows by r per hour since the last compaction and a compaction cost C: the cheapest interval against √(2C/r), then with 4r.

Find the compaction interval

Measure the scan cost per unmerged delta file and the cost of a rewrite, compute the compaction interval τ*, and compare a day at τ*/4, τ* and 4τ*.

Verify a rewrite

Compact 50 Parquet files into one sorted file; compare count and an order-independent fingerprint; then drop a row and replace a row with a duplicate.

Cost of a dimension change: star against OBT

Rename one product category in a star and in one big table: one dimension row against a 20-million-row rewrite.

The definition-variant experiment

Count "active customers in September" three reasonable ways and trace each difference to an unwritten edge case.

Entity resolution: blocking and the threshold

Find typo duplicates among 22,000 customers: blocking cuts the pairs to compare, and the threshold trades false merges for misses.

Build a tiny schema-diff gate

A compatibility classifier for schema changes and ten test cases, checked against the last version only and against every earlier version.

Reader-side default rewrites history

1,000 stored events without delivery_priority, counted under a reader default of STANDARD and then EXPRESS; then with the default written at write time.

Dead-letter rate threshold

100,000 records; a schema change makes 40% invalid halfway. A pure dead-letter queue against a 2% windowed halt threshold.

Alert fatigue by arithmetic

12,000 checks at a 0.001 false-alarm rate for 90 days, with and without a Bonferroni correction, against weekly real defects.

How many rows must you sample, and what does blocking cost?

How large a sample finds a rare defect, against 1 − (1 − p)ⁿ and n ≈ 3/p, and how blocking caps the recall of duplicate search.

Find five bad rows among a million with a Merkle tree

Find 5 changed rows among a million with a Merkle tree, then see why a XOR table hash cannot see duplicated rows.

Read the statistics inside a Parquet file

Read Parquet footer statistics with parquet_metadata: files skippable for a one-hour range, sorted against random; merge two files' statistics by hand.

Lineage coverage: static parse against runtime log

Lineage for 20 small jobs by parsing their SQL and by recording what DuckDB actually scanned: edges found by each.

The ranking feedback loop

52 weeks of catalog search where most users take the top result: does the better table ever win, and what certification bonus does it take?

Check that your dead-man's switch really fires

A scheduler that hangs: a heartbeat checker outside it against the scheduler's own SLA alert.

Fan-out as a batch-size decision

Launch overhead of a subprocess and of a container, the useful share of tasks from 1 s to 600 s, and 1,000 tiny tasks one by one against in 10 batches.

Replay a durable log

A 40-line durable-execution runtime: kill a workflow after two activities, replay it from its log, then branch on the clock and watch the replay diverge.

Head vs. tail sampling

100,000 traces, 1% errors: error traces kept by 1% head sampling and by tail sampling, and the tail sampler's buffer at 1 s and 30 s traces.

Find the false green in your own pipeline

An hourly job starts receiving empty files: job-status alert, freshness check and volume band, and how long each takes to notice.

Base-rate simulation of alerting

A million checks with a 1-in-1,000 incident rate and a perfect-recall detector at four false-positive rates: pages and precision.

Crack a hashed phone number in seconds

Hash every 7-digit number with SHA-256, recover a hashed number by lookup, then try again with a per-record salt.

Re-identify a "5-anonymous" table and measure the uniqueness of quasi-identifiers

100,000 fake people: how many are unique on birth date, postcode and sex, and what k two 5-anonymous releases reach once joined.

Differencing attack and the Laplace mechanism

Recover one salary from two exact sums, then add Laplace noise to counts and measure the error at true counts 5, 100 and 1,000,000.

A privacy budget ledger

A noisy count that charges epsilon to a budget of 1.0: how many of 15 queries are answered, and what averaging repeats costs.

A result cache that leaks, and the fix

A result cache keyed only by query text serves north rows to a south user; keying by identity and policy fixes it and removes the timing signal.

Measure recall against brute-force truth, and see the filtered-search collapse

An HNSW index over 200,000 random vectors: recall@10 and queries per second for efSearch 10 to 200; then a 0.5% filter, post-filtered and pre-filtered.

Three self-joins versus a frontier expansion

A power-law graph of a million vertices: 1- to 4-hop chained self-joins in PostgreSQL against a CSR breadth-first search, from a median vertex and from the top hub.

Supersteps and the straggler tax

10 PageRank supersteps over a power-law graph split across 8 workers by vertex and by edge, with and without a combiner; then PageRank iterations against connected components.

Filter and refine, and the fill ratio

100,000 circles and buffered diagonal lines: bounding-box false positives by fill ratio, STRtree filter-and-refine against brute force, and the raw-degree distance trap.

Cardinality wall and Gorilla encoding

Series counts with and without a user_id label; delta-of-delta and XOR encoding of a million points, regular and noisy; minute rollups of an hour's p99.

Idempotency: a webhook that retries

A charging server that is sometimes slow and a client that retries on timeout: charges with and without an Idempotency-Key.

Offset versus keyset pagination, under writes

Page through a million SQLite rows with OFFSET and with a keyset predicate: time at page 10,000, and duplicates after one insert.

File drop with manifest as commit

Publish file batches with stage, checksum, atomic rename and manifest last; break them three ways; then delete a batch with no schedule.

Mean, percentile averaging and fan-out in 20 lines (30 minutes)

One million latencies, 1% of them slow: the mean, the percentiles, an average of shard p99s, and a fan-out of 100 calls.

Wall time minus CPU time

10,000 small writes with an fsync after each: wall time against CPU time, then one flush per 100 writes; with fsync and with macOS F_FULLFSYNC.

Measure your noise floor and your winner's curse (45 minutes)

An A/A spread over 10 identical runs, a "tuning sweep" of 30 identical configurations, and a blocked against interleaved A/B under background load.

A micro-benchmark that disappears, and a sampling blind spot

A billion x*x computed and discarded, then summed; and a 2 ms sleep once a second profiled at 99 Hz and 999 Hz.

Differential profile of two builds

Profile a JSON-parse-and-insert loop before and after adding a lock, diff the profiles frame by frame, then repeat with one side under extra load.

Catch a benchmark that did no work (30 minutes)

A C loop that "writes" a value 100 million times, with the result unused and then observable, against the ceiling for durable writes.

Random split versus group split versus hash split

50,000 rows for 500 couriers with personal biases: a random split, GroupKFold by courier, and a hash split; then 10% more rows and how many test rows move.