A tester records a passing result in a case management tool, but the requirement-coverage panel still shows the old percentage — what explains the lag, and how do you confirm it?
answer
- computed on read, or stored
- the refresh path is what fails
- compare panel against the requirement itself
- a link change may not trigger refresh
basics
~20 sMost likely the panel serves a stored roll-up rather than recomputing on read, and the refresh that should have followed the result was delayed, batched or missed. Confirm by comparing the panel against the requirement's own links and results.
solid answer
~50 sCoverage panels are computed one of two ways. A **recompute-on-read** panel walks the links and results each time it is opened: always current, and expensive enough that products fall back from it as repositories grow. A **stored roll-up** keeps a precomputed figure refreshed by an event on result recording, by a schedule, or by an explicit rebuild: cheap to read, and stale whenever the refresh does not fire. A lag after a recorded result points at the second design. Confirm it by opening the individual requirement and reading its links and executions directly — the ground truth the panel summarises. If the requirement shows the passing run and the panel does not, it is freshness; if the requirement does not show it either, the result did not land where you think, and you are looking at a link or ingest problem instead.
go deeper
Know that a coverage figure may be a stored summary rather than a live calculation, so a number that has not moved after a result is not automatically a data loss. Check the requirement's own records first.
Be ready to contrast recompute-on-read with a stored roll-up on cost and freshness, and to name the refresh paths — an event on result recording, a schedule, an explicit rebuild — and how each fails.
Demonstrate the bisection between result, link and roll-up, and show that you can tell a scheduled cut-off from a selectively dropped refresh by which other recent changes did appear.
Own the reporting convention: a summarised figure needs a visible as-of time and a rebuild before it is quoted, because an optimistically stale number survives review while a pessimistic one gets investigated.
## Two ways a coverage figure gets produced Every coverage panel answers the same question, but products answer it with one of two very different machines, and which one you are on determines what a lag means. - **Recompute on read.** Opening the panel triggers the query: walk the filtered requirement population, follow each requirement's links, look at the executions in scope, apply the covered condition, produce the fraction. The number is correct as of the moment it rendered. The cost is a join across three growing sets, paid on every open, by every reader. - **Stored roll-up.** The fraction — or a per-requirement covered flag it is summed from — is persisted and served directly. Reads are cheap and constant-cost. Correctness now depends entirely on the refresh path: something must notice a change and update the stored value. Most products that survive at scale end up on the second design, or on a hybrid: recompute for a small population, stored roll-up above some size, with a manual rebuild available. That hybrid is worth knowing about because it produces the confusing symptom where a narrow filter shows the new result immediately and a wide one does not. ## What can break a stored roll-up The refresh path is where the staleness lives, and it fails in recognisable ways: 1. **The refresh is scheduled, not immediate.** The figure is correct as of the last run and will be right later. Nothing is broken; the panel is simply a periodic report and nobody said so. 2. **The refresh event was missed.** Result recording emitted a change that the roll-up never consumed — a dropped message, a failed job, a restart mid-batch. This one does not self-heal; the value stays wrong until something forces a rebuild. 3. **The write path bypassed the refresh.** Results imported in bulk, or written through a different route than interactive recording, sometimes skip the hook that ordinary recording fires. Bulk import is the classic case. 4. **The change was not on the watched path.** Adding a *link* also changes coverage, but some implementations refresh on result changes only, so a newly linked requirement stays uncovered in the panel until the next full rebuild. 5. **A cache in front of the roll-up.** The stored value updated; the reader is served an older rendering. ## Confirming it, rather than guessing The diagnosis is a bisection between three layers — the result, the link, and the roll-up — and it takes only a few minutes: - **Open the individual requirement** and read its links and its executions. This is the ground truth the panel summarises. If the passing run is visible here and the panel disagrees, the summary is stale and the underlying data is fine. - **If the requirement does not show the run either**, stop suspecting freshness. Either the result was recorded against a different case, or against a different cycle than the panel is scoped to, or the case is not actually linked to this requirement. That is an ingest or linking problem wearing a staleness costume. - **Re-open the panel with a much narrower filter.** On a hybrid implementation a small population may take the recompute path and show the true figure, which both confirms the diagnosis and gives you a correct number to work with now. - **Check whether other recent results also fail to appear.** One missing result suggests a single dropped refresh; every result since a given time suggests the refresh path stopped, which is an operational fault rather than a data one. - **Force a rebuild if the product offers one**, then re-read. If the figure corrects, the stored value was stale; if it does not, the data really does not support the number you expected. ## Living with a figure that is not computed on read Once you know a panel is roll-up backed, the working habits change: - **Do not read coverage as a live signal during an execution push.** It is a report with an unstated as-of time, and treating it as a live counter produces exactly the false alarms described above. - **Ask what the as-of time is** and, if the panel does not display one, treat the absence as a defect in the reporting rather than a reason to trust the number more. - **Rebuild before a release conversation**, so the figure you quote and the links behind it agree. - **Distrust upward jumps most.** A stale figure that is too low creates noise and gets investigated. A stale figure that is too high — because a link was removed or a case was deleted and the roll-up never noticed — creates false confidence and gets quoted. The general principle behind all of it: a summarised number and the records it summarises are two different artefacts with two different update paths, and any disagreement between them is information about the pipeline, not just an inconvenience.
- Why is a stale figure that reads too high more dangerous than one that reads too low?A figure that is too low generates noise, so somebody investigates and the staleness gets found. A figure that is too high — the roll-up missed a removed link or a deleted case — reads as good news, gets quoted in a release conversation, and nobody has any reason to check it. Optimistic staleness survives longer precisely because it is comfortable.
- How would you distinguish a missed refresh from a scheduled one you are simply early for?Look at whether other recent changes appear. A scheduled refresh has a consistent cut-off: everything before some time is present and everything after is absent. A missed event is selective — this one result is absent while later ones show up. The first self-heals on the next run; the second needs a rebuild, because nothing will come back for it.
saying these in an interview costs you the question
- Assumes every coverage panel recomputes on read
- Files a data defect without checking the requirement itself
- Believes a stale roll-up always corrects itself eventually
- Ignores that adding a link changes coverage too