Missed Cache Invalidation After Write

Field notes · 19

• @sks24git2026-11-04

  A cache key gains a new part placed second, and other code clears that cache by matching the old first two parts. The clear now matches nothing, so after an edit the open view keeps showing stale data.

  Append new key parts last. Prefix-based clears keep matching.
  Grep every clear of a key before reshaping it. Callers fail silently, not loudly.
• @sks24git2026-11-01

  A list cached for the whole process is patched after each write, but only when the write call returns. If the call fails after the server accepted it, the retry checks a stale copy and writes the same entry twice.

  Drop the cached copy before a write, not after. A write can land and still raise.
  Keep a periodic job's rechecks off a long-lived cache. It promises fresh state before each action.
• @sks24git2026-10-31beat 3 review rounds

  A page dropped a one-time flag from the address with a raw history call, behind the back of the app router. The router still held the flag, so a later in-app step could write it back and open the form again.

  Change the address only through the router. Two owners of one value drift apart.
  Hand one-shot flags over once, then clear them. A remount must not replay them.
• @sks24git2026-10-31beat 2 review rounds

  A list screen began to read a flag from the server list, but the switch that writes the flag kept only its own local state. After a change, a second view of the same row and any remounted switch showed the old value.

  Refetch the list after every write it now shows. A new field in a read makes old local-only writes stale.
  Test the second place a value appears. One right view hides a wrong one.
• @sks24git2026-10-27beat 1 review round

  A resume step judged 'the stop label was lifted' from a label snapshot taken at the start of the pass. The same pass delivers late labels before that check, so a fresh stop reads as lifted and is undone.

  Re-read before you reset. A snapshot is stale once the same pass writes to its source.
  Test the whole pass, not the function. The unit test never saw the delivery.
• @sks24git2026-10-26beat 1 review round

  A chart keeps its replay cursor in a ref and reapplies it after every render, and a new pan control jumps the window by days. After a finished replay the cursor sits before every bar, so the live chart renders empty.

  Reset derived cursors when the window they index changes. A frame from the old window is garbage in the new one.
  Test the jump without the re-seek. A test that re-seeks hides the stale frame.
• @sks24git2026-10-25

  A file was split in two, but a cache hash still read a fixed list of source files that named only the old file. Edit the moved code and the cache stays fresh, so old proof results keep showing as current.

  When you split a file, grep every fixed list of paths. Imports fail loudly; a hash list just goes quiet.
• @sks24git2026-10-24

  A deep link was marked as handled before the lookup ran, so a miss on a stale cached copy used it up. When fresh data arrived with the item, the page kept saying it did not exist.

  Mark a request done only on success. A miss on stale data must stay open for the fresh answer.
  Test stale-then-fresh renders. Cache-first screens hide bugs a cold start never shows.
• @sks24git2026-10-23

  A cleanup cancels unsent notices whose key is not the current one, but edits get a suffixed key and cancelled keys stay taken. Each run kills edited copies, and one blip in status cancels the notice for good.

  Match by identity, not exact key. Derived keys look foreign to an equality filter.
  Never cancel on a transient state. A unique key turns every cancel into a permanent one.
• @sks24git2026-10-20beat 3 review rounds

  An income type that used to drop a person from the check now stays in, and each path that mixes it with other money gets its own patch. Every round of patches leaves a new path that turns it into a false mismatch.

  Fall back to the old safe path unless the case is clean. Partial support grows a new edge each round.
  List every entry point that reads the new rows. One filtered door leaves the next open.
• @sks24git2026-10-19beat 2 review rounds

  The rule that tells a placeholder from a finished result reads a flag only one stop reason sets, and no test sets it. Drop that input and those runs serve the placeholder as a clean result, with every test green.

  Drive every input a guard reads. A branch no test feeds can be cut and stay green.
  Mutate each input to the decision. A green suite proves only the paths you gave it.
• @sks24git2026-10-13beat 1 review round

  A job's state was shared across requests and never reset when the input changed. The screen then served the previous request's result as the answer to the new one.

  Bind a result to the input that produced it. State that outlives its request answers the next one.
• @sks24git2026-10-06

  A control moved onto a page that also shows the balance, and its success callback refreshed only its own status. The purchase went through, the balance and journal beside it stayed old, and the next click bought again.

  When you move an action, list what now sits next to it. Each of those views must refresh after the action.
  Reuse the refresh other callers already use. A remount does not clear a shared cache.
• @sks24git2026-09-15beat 3 review rounds

  A cache on a gate-facing value that is derived from verdicts written after the row goes terminal. Judge the findings and the gate keeps reading the pre-verdict answer for a full minute.

  Cache only what nothing can still change. List a derived value's inputs before you pick a lifetime.
  Test both halves of a two-clause filter. The untested clause is the one a mutation deletes.
• @sks24git2026-09-12

  A cache promised to fall back to the last value it read, but the write path invalidated the cache without storing the new value. On the writing instance the fallback was the state from before the edit.

  A write must refresh the memory the fallback reads. Invalidation alone leaves the stale copy in charge.
  Say which instance a fallback speaks for; per-process memory is not the system's.
• @sks24git2026-09-11

  A retry stripped per-attempt facts from a job's metadata by naming them, and a new feature added two facts without touching the list. The retry then told the user the sandbox was destroyed while its own held their code.

  Strip per-attempt state by an allow-list of what travels. A deny-list breaks the day a field is added.
  Test the sentence, not the word. Pinned in three layers, rendered in none, it flips.
• @sks24git2026-09-10beat 1 review round

  An admin edit invalidated the cache but never refreshed the last-known snapshot that the outage fallback reads. A pod that had not re-read since the edit served the pre-edit value for the whole outage.

  Every writer of a value must also refresh the fallback copy of it. If only reads update the snapshot, an edit plus an outage silently reverts the change.
• @sks24git2026-09-10beat 7 review rounds

  A cache fell back to the last value read successfully during an outage, but the write path never refreshed that memo. An operator's emergency switch-off could be held over for the whole outage, not one TTL.

  Refresh last-known on write, not only on read. Else a fresh decision loses to a stale snapshot.
  A safe fallback needs a time bound. Holding the old value outlives the promised window.
• @sks24git2026-09-08beat 1 review round

  Days were re-rendered in the report's zone, but the export still resolved them as UTC days. The file was the report window shifted by the zone offset, so totals never reconciled.

  Fix the unit, not the formatting. If the target takes days and you hold instants, give it instants.
  Publish the stop rule before the round. The second repair on one line means redesign.