skip to content

You inherit a large application portfolio and a backlog of security findings spread across the OWASP Top 10 categories. How do you decide the order of work, and why is the list's own ranking a poor prioritisation input?

level: principalimportance: should knowfreq 45%

answer

  1. industry incidence ≠ your exposure
  2. reachability x privilege x data sensitivity x fix durability
  3. backlog shape reveals tooling bias, not risk truth
  4. fix the class, not the instance
  5. logging and inventory first; pipeline categories in parallel

basics

~20 s

Rank by your own risk: reachability of the sink, privilege of the executing principal, sensitivity of the data reached, and the cost of the durable fix. The list's ranking is an industry incidence statistic collected from other people's applications, so it says nothing about which of your findings an attacker can actually reach.

solid answer

~60 s

The published order is derived from incidence across a sampled population weighted by generic exploitability and impact. It answers "what is common in the industry", not "what is exposed here". Substituting it for analysis produces the familiar failure: a quarter spent on the top category while an unauthenticated, internet-reachable finding sits further down the list. I rank on four axes. **Reachability** — is the path reachable by an unauthenticated remote actor, an authenticated user, or only an operator? **Privilege** — what does the executing principal hold: a scoped read role or an ambient administrative identity? **Data and blast radius** — what does crossing the boundary reach, and does it enable pivot or persistence? **Fix durability and cost** — a structural fix that eliminates the class portfolio-wide usually outranks several individual patches, because findings of the same class recur. I also separate the categories by remediation shape: components and misconfiguration are largely *pipeline* work that can run in parallel; access control and design need per-flow modelling; logging failures are prerequisites for measuring the rest.

go deeper

for a junior

Not expected to plan a portfolio; recall that severity alone is not priority and that whether an attacker can actually reach the code matters.

for a middle

Give the axes — reachability, privilege, data sensitivity — and note that the published ranking is an industry statistic rather than a plan.

for a senior

Add fix durability: group findings by root cause, prefer the structural control that closes the class, and separate pipeline-automatable categories from per-flow modelling work.

for a principal

Own the sequencing and the meta-argument: inventory and detection first, tooling bias in the backlog itself, capacity split across parallel workstreams, and explicit acceptance of residual risk with the monitoring to observe it.

## Why the published order is the wrong input The list ranks categories using incidence measured across a sampled corpus of applications, combined with generic exploitability and impact weightings. Every term in that computation is about a population, not about your system. Your portfolio has a specific exposure surface, a specific data classification and a specific privilege topology. Two applications with identical findings can differ by orders of magnitude in risk because one sits behind an internal network and mutual authentication and the other is public. Using an industry ranking as a work order is substituting someone else's prior for your own evidence. There is a second, subtler problem: **your backlog is itself a biased sample**. It contains what your tooling can see, and the tooling is strongest exactly where the taxonomy is weakest. A backlog with two hundred dependency findings and no access-control findings is far more likely to mean nobody modelled authorisation than that authorisation is sound. So the first prioritisation act is often not to rank the backlog but to close the coverage gap that the backlog's shape reveals. ## The four ranking axes **Reachability.** Who can invoke the path? Unauthenticated internet-facing beats authenticated user-reachable, which beats operator-only, which beats reachable only by an internal batch job with vetted inputs. This is the single most discriminating axis and the one most often skipped, because tooling reports the defect at its location rather than at its entry point. Tracing from an untrusted entry to the sink is real work and it is worth doing before the ranking, not after. **Privilege of the executing principal.** The same defect has wildly different consequences depending on what the process holds when it is exercised. A code path running with a narrowly scoped read-only credential and a code path running with an ambient administrative identity are separated by a factor that no severity score assigned to the defect class captures. This axis also tells you the cheap mitigation: reducing the principal's privilege caps the impact of every current and future finding on that path without fixing any of them. **Data sensitivity and blast radius.** What is reachable once the boundary is crossed — a public catalogue or the credential store? Does crossing enable *pivot* (reach another system) or *persistence* (survive the fix)? Findings that yield credentials, tokens, signing keys or code execution in a build pipeline dominate everything else, because they convert a bounded incident into an unbounded one. This is why integrity failures in the supply chain rank far above their raw frequency: compromising what produces the artefact compromises every deployment of it. **Fix durability and cost.** Prefer fixes that remove the class. If twelve findings share a root cause — no central authorisation choke point, no managed HTTP client for outbound fetches, hand-rolled query construction in one utility — the structural change is one unit of work that also prevents the thirteenth. Individually patching twelve instances is more expensive and leaves the generator running. Conversely, some categories are cheap and continuous by nature: dependency currency and configuration baselines are pipeline problems that, once automated, cost almost nothing per unit and should not be sequenced behind design work at all. ## Sequencing, not just ranking A portfolio plan has dependencies. **Logging and monitoring failures come early** despite modest headline severity, because without them you cannot tell whether anything else is being exploited, cannot verify a fix in production, and cannot detect the residual risk you consciously accepted. **Inventory comes before everything**: you cannot rank exposure across services you cannot list, and unknown services are systematically the worst configured. **Automatable categories run in parallel** with the modelling work rather than competing with it, because they consume different people. And a **structural control that fails closed** — a deny-by-default authorisation point, an egress proxy for outbound fetches, an enforced managed data-access layer — earns its priority by making the *next* finding of that class impossible rather than by closing the current one. ## Using the taxonomy correctly here The list still has a job in this exercise, just not as a work order. It is a **completeness check**: walk the ten categories against the portfolio and ask what evidence exists for each. Silence in a category is a finding about your assurance coverage. And it is a **communication frame**: risk owners who cannot follow a discussion of an ownership predicate can follow "broken access control, our top category, in the customer portal". Using it to name and group the work while ranking the work on your own reachability, privilege, data and cost analysis is the combination that survives review.

  • A dependency scanner reports 300 vulnerable-component findings. How do you triage them without spending the quarter on it?
    Filter by reachability first — whether the vulnerable code path is actually invoked, and whether it is reachable from untrusted input — then by whether the component runs in a privileged context such as a build agent. Treat the volume itself as a signal that the real fix is process: continuous automated updating with a supported-version policy, so currency stops being a backlog and becomes a pipeline property. Fix the small set that is reachable and privileged by hand, and let automation absorb the rest.
  • Two findings have identical technical severity. What makes one urgent and the other not?
    The entry point and the principal. A defect reachable by an unauthenticated remote actor on a path running with broad credentials is an incident waiting to happen; the same defect in an operator-only tool that runs with a scoped read role is a scheduled fix. Data sensitivity and whether the path enables pivot or persistence break any remaining tie, since anything yielding credentials or build-pipeline access converts a bounded incident into an unbounded one.

saying these in an interview costs you the question

  • Working the categories in published order as if the numbering were a plan
  • Treating the backlog as an unbiased picture of risk rather than a picture of tooling coverage
  • Ranking on defect severity alone with no reachability or privilege analysis
  • Patching instances repeatedly instead of removing the root cause that generates them
  • Deferring logging and inventory work because neither is a vulnerability

context