Result Mixes Reads From Different Times

What goes wrong

One response, screen, or stored record is assembled from values read at different moments or from different sources (a replica and the primary, a cache and the server). Each value was correct when read, but together they describe a state that never existed — the total does not match the line items.

Example

A wallet screen shows the balance from a cached read and the transaction list from a live call two seconds later; the list includes a payment the balance does not.

Not to be confused with

Neither read is wrong on its own, unlike a single cache left stale after a write (Missed Cache Invalidation After Write) or old data sent with a fresh version number (Stale Data With Fresh Version).

Discovered by

@sks24git GitHub

Field notes · 21

@sks24git2026-11-06beat 3 review rounds

A report dropped old verdicts when the author rewrote a post, but kept the old risk score, which only reruns on a new prompt. A clean rewrite still counted as risky, and the miss count failed at every setting.

Reset every input at the same boundary. One stale field mislabels the whole row.
Count what failed, not just what passed. A silent skip reads as a clean run.

@sks24git2026-10-28beat 2 review rounds

A status page read a result list, then the job's status, while a background step could rewrite the list between the two reads. When it landed in that gap, the page showed a final status beside the stale list.

Read the status first, the data after it. A done status must never sit beside data read before it.
List every reader when you add a state. Display-only doors get missed.

@sks24git2026-10-27beat 1 review round

A full resync pages a remote list ordered by last-updated time and deletes each local row it did not see. An item edited while the pages are read jumps ahead of the cursor, is never seen, and gets deleted as gone.

Never delete by absence from a mutable-ordered scan. Page a deletion sweep in a stable order.
Order by update time only for deltas. A delta adds; a sweep removes.

@sks24git2026-10-26

A CI split by timings let each shard fetch the latest timing file and ignore fetch errors. Rerun one failed shard after new timings land, and the broken file slides into a shard that passed, so the build goes green.

Make the test partition a function of the commit. Resolve shared inputs once and pin them for every shard and rerun.
Never swallow a fetch that decides what runs. Fail the shard instead.

@sks24git2026-10-02

A page keeps its last response and renders it while the next scope's request is in flight. Switch company or tab and the old scope's usage rows sit under the new heading until the fetch lands.

Key loaded data by the query that fetched it. Then a stale answer cannot render under a new scope.
Test the switch, not the first load. Every first-load test passes while the swap leaks.

@mxprshn2026-09-15

A cached file count triggered a quota check, then a fresh scan found free space and the save still failed. Use one authoritative snapshot for the gate and its warning so capacity cannot contradict itself.

Make decisions from one snapshot. Mixed cache and live reads can reject valid work.
Pin safety thresholds in tests. Derived fixtures let destructive constants drift.

@sks24git2026-09-12beat 1 review round

A script refused a timestamp younger than ten minutes with a message blaming the operator for passing the wrong instant, while the runbook told them to apply at once. Its count gate also read two different snapshots.

An error must name the condition it tested, not the mistake you expect.
Take both sides of a consistency check in one snapshot, or races read as operator error.

@sks24git2026-09-12beat 1 review round

Two facts both mean "finished" but start minutes apart: the worker's own stamp, and its row going terminal. Guard a screen on one of them and the window between the two shows two contradicting lines.

Guard on every fact that speaks, not the latest one. Two ends that differ in time leave a window where only one is true.

@sks24git2026-09-12beat 3 review rounds

The download filename was built from the revision in the list row, while the bytes came from the one the detail view had loaded. After a rebuild the file is named for the old revision and holds the new one.

Name a file from the same read that produced its bytes. A label and a payload taken from two reads drift the moment one of them refreshes.

@sks24git2026-09-11beat 1 review round

A range check refused values above the top edge and below the bottom one, and every test drove only the top. Delete the lower half and the suite stays green while a year-zero instant lands in an append-only table.

Pin both arms of every bound. One-sided tests make a two-sided check one-sided.
Mutate the guard before trusting the test. A clause whose removal reddens nothing is unprotected.

@sks24git2026-09-10

A sweep kept its keyset cursor in a local and charged the per-tick limit for every company walked, done or not. Each tick restarted at the first id, spent the limit on finished rows, and never reached the rest.

Bound attempts, not rows walked. Finished work must leave the candidate set or it eats the budget.
Keep progress in the query or DB, never in a local. A cursor that dies with the tick is none.

@sks24git2026-09-10

The journal kept the status the client was told; the counter beside it keyed on the row's own status. For seconds after a run finished, a cached 'running' reply counted as the first read of the result.

One fact, one source. When two fields describe the same event, derive both from the same observation or they disagree exactly when it matters.

@sks24git2026-09-10

Two independent-looking reads of instance settings shared one cache entry, so a store outage failed both at once. The path meant to degrade to the old behaviour threw instead, on a money path.

Two readers of one cache entry are one failure, not two. Count entries, not call sites.
A default-off flag still adds a read. Ask what that read does when the store is down.

@sks24git2026-09-09

A signal came from a shell one-liner that only the test double ever replaced, so nothing ran it. A grading row keyed on that signal without checking who stopped the run, grading our own stop as the engine's.

Run the real command in one test. A mocked one-liner is untested code.
Gate a signal on its owner. Engine-cut means nothing if we sent the stop.

@sks24git2026-09-08beat 1 review round

A review retracted the word "once" from every code comment about a backwards-only write, and the same fix added "once" to the canonical scenario doc. The text people treat as truth now promised what the code cannot do.

Grep the word you retract across every prose form. Scenario files and docs lie longer than comments.
Narrow a promise everywhere or nowhere. One stale copy becomes the canon.

@sks24git2026-09-06beat 13 review rounds

A drop-resolved helper matched by object identity while every restore path parsed a fresh object. The resolved attempt was never dropped and the fallback re-surfaced it as pending on reopen.

Match persisted records by key, never by reference. Anything that crosses storage comes back as a new object.

@sks24git2026-09-06beat 4 review rounds

A preview zeroed the promo bonus whenever a retry was pending, even when the frozen body carried the promo. The user saw a smaller total than the replay would actually credit.

Derive previews from the frozen request. Live inputs and the replayed body diverge the moment you freeze one of them.

@sks24git2026-09-06beat 1 review round

A promo-code field was cleared on dialog open while the frozen retry body still carried the code. The replay sent one code, the screen showed another, and the bonus preview lied to the user.

Freeze the whole request or none of it. A retry that replays half its inputs from live state is not idempotent, it is two different requests.

@sks24git2026-09-03beat 5 review rounds

A race test opened its window after the first read, but the code read again before taking the lock. Move the guarded read out from under the lock and every case stays green while two hunts run for one commit.

Open the race window just before the lock. A hook on the first read pins nothing about where it runs.
Retest the siblings of a fixed race. The window stays open for rows you did not name.

@sks24git2026-09-02beat 2 review rounds

A transaction decided on a row it read, then rebuilt the set to act on from a second, filtered read. A writer that takes no such lock committed between the two, the row dropped out, and the guard never ran.

Act on the id you decided on, not on a re-read. One lock does not bind a writer that skips it.
Put the race hook where the new window is. A hook on the old one ships the new one green.