Old Rows Missing New Required Field

What goes wrong

A change adds something new rows carry — a type column, a lookup key, a new spelling of a marker — but rows written before the change are never updated (no backfill). The whole history is misclassified, invisible to the new query, or still served in the old shape.

Example

A migration adds a 'kind' column; new orders fill it, old ones stay NULL, and the filter by kind never shows any old order.

Not to be confused with

Not a cache missed after a known change (Missed Snapshot Refresh) and not several kinds of 'empty' folded into one (Empty states lose their meaning); the old rows are current data that simply predate the fact the reader now requires.

Discovered by

@sks24git GitHub

Field notes · 12

@sks24git2026-11-04beat 1 review round

A fix clears a stale debt at the moment a result is voided, but results voided before the fix shipped are never visited again. Old records keep the very bug the fix claims to end.

Fix the data you already have, not only new events. A write-time fix leaves history broken.
Prefer a sweep that converges. It heals old rows and missed writes alike.

@sks24git2026-11-04

A new display reads a column that every current write path fills. Rows written before that column existed have it empty and render a misleading default.

Plan for rows older than your new column. Backfill them or render "unknown" for the gap.

@sks24git2026-11-04beat 1 review round

A change makes an old optional field required before a bill can be issued. Existing records never filled it, so those customers can no longer get a bill and see only a generic refusal.

Backfill or default old rows before you require a field. New rules hit old data first.

@sks24git2026-11-02

A scorer was fixed to stop crediting a different bug at a nearby line, but its upsert only ever raises a score. Every row scored under the old rule keeps its false credit, and the totals never age it out.

Rescore history when a scoring rule tightens. A keep-the-max write turns a fix into a forward-only patch.

@sks24git2026-10-31beat 3 review rounds

A rename gave stored questions new ids, but rows saved under the old ids stayed open. The planner never matched them again, so old questions were never re-sent and their follow-ups skipped the wait.

Map old ids at every read, not just one. Answers, open rows, gates and lookups each need it.
Test a rename with rows saved before it. Fresh fixtures never hold old ids.

@sks24git2026-10-31beat 3 review rounds

A routing fix moved readers from labels to a field in old records, but old records still held the wrong value. Questions that labels sent to a person now looked like bot work, so no person and no bot ever picked them up.

Backfill old records when you switch the source of truth. Readers trust the new field at once.
Fail closed to a human on mixed signals. A lost question costs more than a spare ping.

@sks24git2026-10-30beat 1 review round

A new version record was written only when the schema step ran, and the first upgrade skipped that step because the old record matched. The new record never appeared, so the next upgrade re-ran old schema mid-rollout.

Backfill the new record on the path that skips work. A migration that writes only when it acts leaves the steady state unrecorded.

@sks24git2026-10-18beat 4 review rounds

A ranking table knew only the four current severity words, while old rows still store an earlier set of codes. When a long list is capped, an old critical item ranks as unknown and is cut first.

Read stored values through the map the parser uses. Old rows keep old spellings long after the writer changed.
Test the fallback rank. It quietly decides what a cap throws away.

@sks24git2026-09-28

A parser change made more links count, and records stored under the old rule were checked with the new one. Old records stopped loading, and a hook that threw away its error output dropped their verdict.

Check stored state with the rule that wrote it. A wider parser turns old valid records into errors.
Never discard a hook's error output. It hides the failure nobody reports.

@sks24git2026-09-27

A rule change is applied to review rounds recorded under the old rule, so history that passed yesterday fails today. One old round turns invalid, the chain breaks, and every later step on that task refuses to run.

Judge old records by the rule they were written under. A new rule applied backward turns valid history into errors.
Test a new rule on history made before it. Fresh fixtures pass by design.

@sks24git2026-09-10

A constraint was added NOT VALID so the legacy rows a backfill skipped would not be rejected. NOT VALID spares them only at add time: the next update of such a row is checked, and deleting that user broke.

NOT VALID exempts existing rows, never later writes to them. A row you skip must still satisfy the constraint before it can be updated.
Test the skipped population, not the migrated one.

@sks24git2026-09-05beat 3 review rounds

A phased change updated the code comment and the UI, but the endpoint's API description still said the write sets one flag and nothing more. Doc readers conclude the new response fields can only be stale.

When code ships in phases, a tool every surface that describes it. Prose inherits the whole feature; the third copy you forgot is the one integrators read.