skip to content

A threagile run emits 240 risks whose tracking status lives in the repo — who may mark one accepted?

level: principalimportance: nice to knowfreq 31%

answer

  1. the status field is a business decision
  2. merge rights are not authority
  3. acceptance needs an owner and an expiry
  4. watch for bulk flips in one commit
  5. the tracking file is the audit trail

basics

~20 s

Whoever owns the consequence, not whoever can merge. Storing tracking statuses in the model repo makes acceptance a one-line code change, so it needs a named accountable owner, a stated expiry and a review path stricter than an ordinary merge.

solid answer

~50 s

threagile keys each generated risk to a deterministic id and lets the model repo carry a tracking entry per id with a status such as unchecked, accepted, mitigated or false-positive. That is valuable: acceptance becomes diffable, attributable and reproducible per commit instead of living in someone's inbox. It is also the hazard, because accepting risk is a business decision reduced to editing a field, and merge rights are not authority to carry exposure on the organisation's behalf. So I separate the two: the tracking section gets its own reviewers, an acceptance must carry a justification, a named accountable owner and a review date, and the author of the change that created the risk does not accept it. The number to watch is not 240 — it is how many statuses flipped in one commit with the same reason.

go deeper

for a junior

Know that a status such as accepted records a business decision, not a technical fix, and that a real person has to own the consequence if the risk is realised.

for a middle

Explain what a tracking entry does mechanically: it attaches a status to a specific generated risk id, so reruns carry decisions forward instead of re-reporting every triaged risk as new.

for a senior

Show how you keep triage honest — per-risk justification, a review date, an owner who is not the change author, and attention to commits that flip many statuses at once.

for a principal

Own the governance: who is entitled to accept risk on the organisation's behalf, how that entitlement is expressed in the repository's review rules, and how acceptances are made to expire rather than quietly becoming permanent.

## What the mechanism is When a source-defined model is evaluated, the tool generates a risk list. Rerun it after any edit and the list regenerates — which raises an obvious problem: how does a decision made about a risk last week survive a rerun today? threagile solves it by giving each generated risk a **deterministic synthetic id** derived from the rule and the assets it fired on, and letting the model repository hold a **risk-tracking entry** per id. Each entry carries a status — values such as unchecked, in-discussion, accepted, in-progress, mitigated or false-positive — plus fields for who decided and when. On the next run the tool reconciles the generated list against those entries, so triaged risks stay triaged and genuinely new ones stand out as unchecked. That reconciliation is the feature. Without it, a first run of 240 risks would arrive again, undifferentiated, on every commit, and the report would be ignored within a week. ## Why acceptance is the interesting field The statuses are not equivalent. *Mitigated* is a claim that work was done, and it is falsifiable — someone can go look. *False-positive* is an argument about the rule, and it is contestable on technical grounds. **Accepted** is different: it says the exposure is real, nothing will be done, and the organisation will carry the consequence. That is not an engineering statement. It is a decision about money, customers, regulatory exposure or reputation, made on behalf of people who are not in the pull request. And in this format it costs one line. An engineer under delivery pressure, looking at a red report blocking nothing in particular but making everyone uncomfortable, can change a field and the discomfort disappears. Nothing about the file resists that. ## Who may set it The principle: **acceptance belongs to whoever owns the consequence.** For a risk to applicant financial data it is the person accountable for that data, not the service team; for a risk to a fleet's availability it is whoever answers for the outage. That person is usually not the one who can merge to the model repo, and merge rights must not be allowed to imply the authority. Making that real in the repository: - **Separate the tracking section from the model.** Different reviewers for the file or section that carries statuses than for the architecture itself. Changing the design and accepting the risk it created should not be the same approval. - **Author is not approver.** The person whose change produced the risk cannot be the person who accepts it. - **Require a justification field.** Free text that says why the exposure is tolerable, in terms of the affected asset and the compensating conditions — not just "low impact". - **Require an expiry or review date.** An acceptance with no end date is a permanent decision made by someone who has probably left the team. Expired acceptances should return to unchecked. - **Name the accountable owner in the entry.** Not the team, a person. - **Treat false-positive as needing a rule-level argument.** If the rule is wrong for this shape of system, that is a statement about the rule, and it should be argued once and centrally rather than silenced per risk. ## The insider angle worth naming Once statuses live in the repo, the file **is** the audit trail for risk decisions. That makes it an asset in its own right, with the property this tree cares about: non-repudiation. Anyone with commit access can quietly reclassify a risk, and if that goes unreviewed the record of what the organisation knowingly accepted becomes untrustworthy. Protecting the tracking section — required review, protected path, meaningful history — is protecting the evidence, not the report. ## Handling the first 240 A first run producing hundreds of entries is normal, and the honest response is not to accept your way to a clean report. It is to treat the list as a backlog: 1. Sort by the criticality of the data assets and the exposure of the technical assets involved, using the ratings already in the model. 2. Accept nothing on the top-value assets in the first pass — those deserve a real decision. 3. Expect a long tail of rule-driven baseline findings; batch those into a small number of explicit, argued positions rather than 180 individual justifications. 4. Track the ratio over time. A programme where nearly everything ends up accepted and almost nothing mitigated is not managing risk; it is documenting resignation. ## The failure mode to watch for Normalised deviance. Not one bad acceptance, but the slow slide where accepting becomes the default first move, justifications become copy-paste, dates stop being set, and the report becomes a formality everyone knows is green because it was made green. The tell is visible in the history: bulk status flips, identical reasons, and no risk that ever moved from accepted back to open.

  • What are the tells that risk tracking has become a rubber stamp?
    Statuses flipped in bulk in a single commit; justifications that repeat verbatim; almost everything accepted and almost nothing mitigated; no expiry or review dates; acceptance authored by the same person as the change that created the risk; and no entry that has ever moved from accepted back to open. Any two of those together mean the file is documenting a decision nobody actually made.
  • Why keep statuses in the model repository rather than in a ticket tracker?
    Because they reconcile with the generated risk ids, so a rerun carries decisions forward instead of re-reporting everything as new, and the decision diffs alongside the design change that prompted it. The cost is that you lose the tracker's approval workflow and its visibility to non-engineers, which is why teams often mirror acceptances into the tracker and treat the repo entry as the machine-readable record.
  • How would you triage a first run of several hundred risks without accepting most of them?
    Sort by the criticality ratings already in the model and work top-down. Give the risks touching the highest-value data and the most exposed assets real decisions with owners. Batch the long tail of baseline rule findings into a few explicit argued positions rather than hundreds of individual justifications, and treat the remainder as a backlog with owners rather than something to be cleared.

It is like letting anyone who can edit the ledger also sign off the write-off. The recording and the deciding are different jobs, and only one of them belongs to whoever holds the pen.

saying these in an interview costs you the question

  • Says whoever opens the pull request can accept the risk
  • Uses false-positive as the cheapest way to silence a rule
  • Accepts risks with no owner and no expiry date
  • Thinks a green report means the risks were addressed
  • Bulk-accepts the first run to quiet the report

context