What is your definition of done for a threat-model finding before its ticket can be closed?
answer
- Absence is harder to prove than presence
- Agreement is not existence
- Which environment does the threat live in
- Would anything go red if the control vanished
- Update the picture, record what closure assumed
basics
~20 sDone means the agreed control is merged and running in the environment the threat targets, and evidence exists that fails if the control is removed. A design note, a ticket comment or a reviewer's approval is not done.
solid answer
~50 sI hold a threat finding to three conditions. First, the control is merged and deployed where the threat actually lives — a control running only in staging leaves a production threat open. Second, there is evidence tied to the ticket that would fail if the control were removed or misconfigured: a check, a constraint, a policy assertion. Third, the model is updated so the diagram and its notes reflect the control that now exists, and the closure records what it rests on. A B2B document-signing service taught me the cost of skipping this: the audit-log tampering threat was marked done on the strength of a design note saying the write path would be append-only. The note was accurate and the change was never merged, so a green ticket said the non-repudiation threat was handled while the log stayed editable for months.
go deeper
Remember the core rule: a threat is not done because it was discussed or designed. Something has to be merged and running, and something has to check that it stays that way.
Be ready to explain the three conditions and, in particular, the negative-sensitivity test for evidence — would anything fail if the control disappeared. Know why happy-path checks are not evidence about a threat.
Demonstrate judgment about environments and bypass paths: staging-only enforcement, a second write path to the same asset, a control that ships and then quietly regresses. Give a real example of a closure that was accepted too early and what it cost.
Own the assurance model: how closure stays self-service without becoming self-certification, what a sampling audit of closed findings looks like, and how you keep the bar high without making a security engineer the bottleneck on every ticket.
### Why a threat needs its own definition of done Ordinary feature work closes when the behaviour a user asked for exists. A threat closes when a behaviour an adversary wanted stops being available — an absence, not a presence. Absence is much easier to claim than to demonstrate, which is why threat tickets close on weaker evidence than feature tickets and why teams end up with backlogs that look finished while the system is unchanged. ### Terms, kept straight - A **threat** is what could go wrong: an adversary in some position doing something to an asset. - A **vulnerability** is the specific flaw that makes the threat possible in this system. - A **control** is what you build so the threat stops working. - **Evidence** is the artifact that shows the control is presently in force. Closing a ticket is a claim about the control and the evidence, not about the threat. The threat itself never goes away; you assert that it is no longer reachable in the running system. ### The three conditions **1. Merged and running where the threat lives.** A control that exists on a branch, in a design document, or in a lower environment does not close a production threat. The environment matters more than people expect: a control enforced in the application but bypassable by a second path — an admin console, a batch job, a support tool that writes directly to the store — has not closed the threat, because the model named the asset, not the code path. **2. Evidence that fails without the control.** This is the sharpest test available and the one that separates a real closure from a hopeful one. Ask: if someone deleted this control tomorrow, what would go red? If the answer is "nothing until the next model review", the ticket is not closed, it is unmonitored. Evidence can be a check that exercises the abusive input and asserts the refusal, a database constraint whose absence breaks a check, a configuration assertion, or a monitor that alarms when the control is off. The property required is negative sensitivity: the evidence must be capable of failing. Evidence that only exercises the happy path proves the feature still works, not that the threat is blocked. **3. The model updated, and the closure recorded.** When the control ships, the picture changes: a boundary moves, a store becomes append-only, a new component appears. If the diagram still shows the pre-control design, the next person to model this system reasons about a system that no longer exists. And the ticket should record what the closure rests on — which change carried the control, which evidence guards it, and what was assumed to remain true — so that a later reader can judge whether the closure still holds. ### The failure this prevents A B2B document-signing service modeled tampering with its signature audit log — the asset is non-repudiation, the record that a named person signed a specific document at a specific time, and the adversary of concern was an operator with legitimate database access. The agreed control was an append-only write path with a hash chain over entries. The threat's ticket was closed at the end of the design review, on the strength of a note describing that control, because the design was agreed and the sprint was ending. The implementation slipped, then was descoped in favour of a customer-facing feature, and nothing ever reconciled the descoping with the closed threat. Months later the log was still a mutable table. Notice what went wrong: nobody lied and nobody was careless. The ticket simply used the wrong closure criterion — agreement instead of existence — and the backlog then reported the threat as handled, which is worse than reporting it as open, because it stopped anyone looking. ### Common weak closures, and what they actually mean | Closure claim | What it really establishes | | --- | --- | | "The design review agreed the control." | The team knows what to build. | | "The pull request is open." | Someone started. | | "It is enforced in staging." | The control can work; production is untested. | | "A reviewer approved it." | One person read the change. | | "There is a test." | Something runs; ask whether it fails when the control is removed. | | "Control is merged, deployed, and a check fails without it." | Done. | ### Who closes The engineer who did the work should be able to close it, provided the evidence is attached and mechanically checkable. Requiring a security engineer to hand-close every finding turns a bottleneck into a queue and teaches teams to batch and hurry. The scalable version is that the criterion is objective enough that closure can be self-served and later audited: a sample review of closed threats that asks, for each, "show me the thing that would fail if the control vanished". A closure that cannot answer that question re-opens.
- The control shipped, but the only automated check exercises the normal path. Is the threat closed?No. A happy-path check proves the feature still works; it would stay green after the control was removed, so it is not evidence about the threat at all. The property you need is negative sensitivity — something that goes red when the control is gone. Until that exists, the honest state is 'control shipped, unguarded', which is a different and lesser status than done.
- Who should be allowed to mark a threat finding done — the engineer or a security reviewer?The engineer, if the criterion is objective: control merged and deployed, evidence attached that can fail. Central sign-off on every finding becomes a queue, and queues teach teams to batch and rush. Keep assurance as a periodic sample audit of closed threats that asks what would fail if the control were removed, and re-open the ones that cannot answer.
- The control is enforced in the API but a support tool writes to the same store directly. Closed?Open. The model named the asset and the adversary, not one code path, so a second write path that bypasses the control leaves the threat reachable. This is why closure should be argued at the level of the flow and the trust boundary from the diagram: enumerate every path to that asset and confirm the control covers all of them, or narrow the ticket explicitly to the path it did cover.
saying these in an interview costs you the question
- Closes a threat on a design decision or a ticket comment
- Counts an open pull request as mitigation
- Accepts a happy-path test as proof the control works
- Closes a production threat on a staging-only control
- Leaves the diagram showing the pre-control design
- Confuses reviewer approval with a control existing