skip to content

How do you decide which open defects ship as known issues rather than block a release?

level: principalimportance: should knowfreq 44%

answer

  1. Deferral is a decision, not a queue
  2. Bounded harm versus harm that keeps accruing
  3. Detectable by the user, or silent
  4. Every entry needs owner, workaround, revisit date
  5. Publish outward, then expire by default

basics

~20 s

Deferral is an explicit, owned decision, not a queue that fills by default. Ship a defect as a known issue only when its harm is bounded and reversible, a workaround or accepted-risk statement exists, an owner and revisit point are named, and support and users are told.

solid answer

~50 s

I set it up as a decision with a shape rather than a judgement call per defect. **Who decides**: the release owner, accountable for the release, on a written risk statement from test and engineering — not test alone and never the assignee alone. **What qualifies**: harm that is bounded, visible and reversible. A defect that produces wrong stored values, silently loses user work, or is hard to detect after the fact is a poor deferral candidate however rare it is, because the cost keeps accruing after ship and the cleanup is unbounded. A cosmetic or workaround-covered defect is a good one. **What the decision must carry**: an identified record, symptom in user language, who is affected, the workaround or accepted risk, an owner and a revisit date. **Where it goes**: the published known-issue list, in front of support and users, not only in the tracker. Then a standing re-triage so the list does not become a graveyard where deferral is permanent by neglect.

go deeper

for a junior

Know that shipping with an open defect is a deliberate decision someone makes and records, not something that happens because time ran out, and that the entry needs a workaround users can follow.

for a middle

Be ready to say what a known-issue entry must contain — identifier, user-facing symptom, who is affected, workaround, owner, revisit point — and why support and documentation need it, not just the team.

for a senior

Argue the qualification test: bounded and reversible harm can be deferred, harm that accrues silently after release usually cannot, whatever its rating. Show how you surface that distinction in the release conversation.

for a principal

Own the policy and the failure mode. Decide who signs a deferral, what default answer the process starts from, how entries expire, and how the list stays small enough that the team still reads it.

## Deferral is the one lifecycle decision that ships Every other terminal state settles a report internally. Deferral pushes a known defect into users' hands deliberately, so it is the transition that deserves the most structure. The failure mode is never a single reckless decision — it is drift: a queue that fills because nobody had time, then gets summarised as "known issues" in the release notes without anyone having decided anything. ## Who owns the call The decision belongs to the person accountable for the release — typically the release or product owner. Testing's job is to state the risk, not to grant or withhold permission; engineering's job is to state cost and blast radius; the owner chooses. Two anti-patterns are worth naming in an interview: - **Test as gatekeeper.** When testing has the veto, engineering argues the risk down rather than describing it, and the conversation becomes political. - **Assignee as decider.** The person who would otherwise have to fix it tonight is the worst-placed person to judge whether it can wait. Practically: a standing deferral review, a small quorum, and a default of *no* — a defect ships as a known issue only when someone said so, on the record. ## What makes a defect a legitimate known issue The useful axis is not how rare or how ugly it is, but **how the harm behaves after release**: - **Bounded and reversible** — a wrong label, a misaligned layout, a slow screen with a workaround. The damage stops when the fix ships. Good candidates. - **Detectable** — the user can tell something is wrong and can react. A visibly failed submission is far safer to defer than a silently mis-saved one. - **Accruing** — wrong values written to stored records, lost work, anything that corrupts state or misinforms a downstream decision. Deferring these means also owning the cleanup for every day they ship, and that cost is usually far larger than the fix. A tax-filing wizard that writes a wrong filing date onto submitted returns is the archetype: rare, cosmetic-looking on screen, and unbounded once returns are filed. - **Trust-shaped** — anything that touches money, identity, permissions, or a legal or regulatory obligation. These are usually not deferrable at all, and the deferral discussion should not consume the room's time pretending otherwise. Severity and urgency ratings are inputs to this conversation, not the answer to it — two defects with identical ratings can differ completely on whether the harm keeps accruing. ## The known-issue entry as an artefact A deferral is only real if it produces something a stranger can act on. A defensible entry carries: 1. the record identifier, so it stays linked to the evidence; 2. the symptom in **user language**, not internal terms — support reads this, not the code; 3. who is affected and roughly how often, honestly stated; 4. the workaround, or an explicit statement that there is none and the risk was accepted; 5. a named owner; 6. a revisit point — a date or a release, not "when we get to it". Missing the workaround is the most expensive omission, because the support cost of a defect with no advice is many times the same defect with a paragraph of advice. ## Publish it outward The list belongs where support agents, documentation and, where appropriate, users can see it — not only inside the process where the team already knows. Deferral is a decision to accept harm; the mitigation is warning the people who will absorb it. A team that defers 23 defects and tells nobody has not accepted risk, it has transferred it silently. ## Stopping the graveyard Deferred defects rot in a predictable way: the list grows, nobody rereads it, and after two releases it is treated as an archive. Countermeasures that work: - **Expiry by default.** Every entry has a revisit date; on that date it is re-triaged and either fixed, deliberately re-deferred with a new date, or closed with a stated reason such as the behaviour being accepted as designed. Silence does not renew a deferral. - **A cap you actually feel.** Some teams fix the list at a size and require removing one before adding another. Crude, but it forces the conversation the queue otherwise avoids. - **Re-triage on change of context.** A deferral is a judgment about a moment. When the feature's usage jumps, a regulatory deadline lands, or a related area changes, the old judgment is stale and the entry deserves a fresh look. - **Ageing as an input.** A defect deferred three releases running either matters and should be scheduled, or does not and should be closed honestly. Perpetual deferral is a decision nobody made. ## What an interviewer is listening for Not a policy recital. They want to hear that you distinguish bounded harm from accruing harm, that you put the decision with the accountable owner rather than with whoever pushes hardest, that you insist on a workaround or a written accepted risk, and that you have a mechanism — not an intention — that stops the list from silently becoming permanent.

  • How do you stop a known-issue list becoming a graveyard?
    Make renewal explicit rather than automatic: every entry carries a revisit date, and on that date it is fixed, deliberately re-deferred with a fresh date and reason, or closed with a stated resolution. Silence must never renew a deferral. A visible cap on list size, and re-triage whenever usage or context changes, both force the conversation the queue otherwise avoids.
  • What changes when the deferred defect sits against a regulatory or statutory deadline?
    The deferral window stops being yours to choose. The decision becomes whether the defect can be fixed before the date, and if not, what mitigation exists for the people who hit it in the meantime — typically a documented manual path plus proactive notification. It also raises who must sign: an accepted risk with legal or compliance consequences is not a release owner's call alone.
  • A defect has been deferred for three consecutive releases. What would you do with it?
    Force a terminal decision. Either it matters, in which case it gets scheduled with an owner in the next release, or it does not, in which case close it honestly — as accepted behaviour or as not worth fixing, with the reasoning recorded. Repeated deferral is the process failing to make a decision, and leaving it open keeps costing triage attention and support time for nothing.

A known-issue list is a loan, not a write-off: it carries interest in support cost, and it needs a repayment date somebody is accountable for.

saying these in an interview costs you the question

  • Treats the deferred queue as a place things drift into
  • Lets the assignee decide their own defect can wait
  • Defers a defect that writes wrong values into stored records
  • Writes a known-issue entry with no workaround or owner
  • Keeps the list internal instead of telling support
  • Renews deferrals by silence rather than by decision

context