skip to content

Your platform wants to auto-close unreachable dependency findings across 400 services — what do you require first?

level: principalimportance: nice to knowfreq 33%

answer

  1. a verdict has a shelf life
  2. deprioritize with expiry, do not close
  3. key it to artifact and analysis, not the advisory
  4. carve out the expensive-to-be-wrong cases
  5. sample for false suppressions

basics

~20 s

Require that the verdict expires and re-runs on every rebuild, that it is keyed to the exact artifact and analysis that produced it, that each decision carries owner and evidence, and that high-consequence surfaces are carved out.

solid answer

~50 s

The pitch is sound — engineer attention is the scarce resource and most findings are not exposures — but permanent closure is the wrong mechanism. A reachability verdict is a claim about one artifact, analysed by one tool with one entry-point set, on one date; any commit can invalidate it, and a package that was only in a local toolchain can move into the shipped path without anyone noticing the old note is now false. So I would insist on four things: deprioritize with expiry rather than close, so every rebuild re-decides; key the suppression on package, version, artifact digest and analysis identity, never on advisory id plus package name; retain owner, date, evidence and the flip condition on each record; and carve out internet-facing or multi-tenant services, dynamic languages where static reachability is weakest, and anything under active exploitation. Then measure the false-suppression rate by sampling, not the volume suppressed.

go deeper

for a junior

Understand that a triage decision is written down and can go stale, so findings are usually deprioritized with a review date rather than deleted outright.

for a middle

Be able to explain what a suppression must be keyed on — package, resolved version, artifact, analysis — and why a key that ignores those keeps applying after the code changes.

for a senior

Show how you would operate this: expiry on rebuild, retained evidence and flip conditions, carve-outs for exposed or dynamically wired services, and a re-open path for owners who disagree.

for a principal

Own the tradeoff between engineer attention and residual risk, decide who holds the risk when the mechanism is wrong, and pick metrics — sampled false-suppression rate, not suppression volume — that make the programme defensible to a customer or an auditor.

## Why the request is reasonable At four hundred services the queue is dominated by findings that will never be exposures, and a team that reviews all of them reviews none of them properly. Automating the obvious no-risk cases is genuinely the right direction; the judgment is in *what automation is allowed to conclude* and *for how long*. ## Close is the wrong verb Closing destroys the queue's memory. The safer construction is **deprioritize with an expiry**: the finding stays in the inventory, drops out of anyone's working set, and is re-decided automatically on the next build of that artifact. Two properties follow. First, the decision is never older than the code it describes. Second, if the automation is later found to be wrong about a class of cases, you can re-open that class, which you cannot do once the records are gone. ## Key the decision to what it actually depends on The single most damaging design error here is keying a suppression on *(advisory id, package name)*. That key survives everything: a refactor that introduces a call to the vulnerable function, a version bump, a component moving from a local toolchain into the shipped runtime path, a service acquiring a new entry point. The note keeps suppressing while the fact it recorded stops being true, and nobody re-reads it because it is no longer in anyone's queue. Bind it instead to everything the claim rests on: the package identity and resolved version, the artifact or commit digest analysed, the analyser and its entry-point set, and a timestamp. Any change to those invalidates the suppression by construction, which turns a stale-note problem into a re-analysis problem — a much better problem to have. ## What each record must retain A year from now someone — an auditor, a customer's security reviewer, an engineer during an incident — will read one of these decisions cold. It has to answer, on its own: which artifact and version it applies to; who or what decided, and when; the evidence, meaning the static verdict together with the entry points modelled and any runtime observation with the window it covered; the stated condition that would flip it; and the expiry. A row that says only "unreachable" is unauditable and, in a conversation with a customer about why a shipped artifact contains a known-vulnerable component, indefensible. ## Carve-outs, decided in advance Automation should refuse to act where being wrong is expensive: - **Exposure.** Internet-facing and multi-tenant services, where the attacker position is cheap to occupy and the asset is somebody else's data. - **Language and stack.** Dynamic imports, reflection-driven wiring and plugin architectures make static unreachability least trustworthy; the tool's error rate is not uniform across the estate, and the policy should not pretend it is. - **Active exploitation.** Anything the industry is currently seeing used goes to a human regardless of the verdict. - **Thin evidence.** A verdict with no runtime corroboration in a stack where corroboration is available is not the same input as one with it. ## Ownership and appeal The platform team owns the mechanism; the service owner still owns the risk. That split has to be explicit, or the first wrong suppression becomes an argument about whose fault it was during an incident. Give service owners the ability to opt a repository out, give security an override, and publish what the automation did per service so the decision is visible rather than silent. ## Measure the right thing The tempting metric — findings suppressed — rewards exactly the failure mode you fear. Measure instead the **false-suppression rate**: sample a percentage of auto-deprioritized findings each month, review them by hand, and publish how many were wrong. That number is what tells you whether to widen the automation, tighten the carve-outs, or stop. Pair it with time-to-remediate on the findings that *did* stay in the queue, since the whole justification for the programme is that attention moved to them. ## The answer an interviewer is listening for Not "no". A principal who blocks the automation has not solved the scale problem. What distinguishes the answer is treating the verdict as a perishable, attributable claim rather than a permanent fact, and building the mechanism so that its own errors are detectable and reversible.

  • Why is keying a suppression on advisory id plus package name specifically dangerous?
    Because that key outlives every fact the decision rested on. The same package can gain a call site, change version, or move from a local toolchain into the shipped runtime path, and the suppression keeps applying silently. Keying on resolved version, artifact digest and analysis identity makes the record self-invalidating instead of quietly wrong.
  • How do you show a customer's security reviewer that this programme is not just hiding findings?
    By showing the sampled false-suppression rate over time, the retained evidence behind individual decisions, and the carve-out list that keeps exposed services out of the automation. The argument is that decisions are attributable, time-bounded and audited — not that fewer findings exist.
  • A service owner disputes an auto-deprioritized finding. What should the process allow?
    A one-click re-open plus a repository-level opt-out, both without needing the platform team. Disputes are signal: every re-open should feed the sample you review, because a cluster of them in one language or framework usually means the tool's model is weak there and the carve-out list needs an entry.

saying these in an interview costs you the question

  • Auto-closes findings permanently across the fleet
  • Keys the suppression on advisory id and package name only
  • Keeps no owner, evidence or expiry on the decision
  • Measures success by how many findings disappeared
  • Applies one policy uniformly across every language and exposure level

context