Vulnerability Ownership Is the Metric Hiding Inside Your MTTR

Everyone measures mean time to remediate. Almost no one measures the step that actually eats the clock: finding the human with the authority to approve the fix. Call it Mean Time To Owner, and it's why remediation takes weeks.

Elad Ben Meir | Sep 23, 2026

TL;DR

  • Everyone measures MTTR. Almost no one measures vulnerability ownership, the reason it stays high.
  • MTTO, mean time to owner, is the gap between a finding entering the queue and the right owner taking responsibility for it.
  • Up to half of remediation tickets bounce back because the owner was wrong on arrival.
  • Ownership data is stale the day it's entered. CMDBs never catch up.
  • Decide once. Resolve forever. That's what drives MTTO to zero.

A critical finding has been open for three weeks. The patch is well understood. The change is routine. On a good day the fix itself would take an engineer twenty minutes.

It is still open, because for three weeks no one has answered one question: whose job is it to make the change?

The ticket first went to a team that said the server had moved to another group last quarter. That group said they inherited the box but not the application running on it. The application owner left the company in the spring. Someone suggested checking the CMDB. The CMDB lists an owner who now runs a different division and has not touched the system in a year. Meanwhile the vulnerability sits there, exposed, while the organization performs three weeks of archaeology to produce a single name.

You are measuring MTTR. You are not measuring the reason it is high. The reason has a name most programs never track: vulnerability ownership, and the time you lose finding it.

The metric nobody tracks

Every exposure program watches mean time to remediate. It is the number on the board slide, the one benchmarked against peers and argued over in quarterly reviews. But MTTR is a total. It bundles several very different activities into one figure, and in doing so it hides the step that actually eats the clock.

That step is finding the owner. Call it MTTO, mean time to owner: the time between a finding landing in the queue and the right human, the one with the authority and the context to approve a fix, actually taking responsibility for it. It is unglamorous. It never appears on a dashboard. No vendor sells a module to reduce it. And in program after program, it is the single largest reason remediation takes weeks instead of hours.

We see the evidence in the tickets. Up to half of all remediation tickets bounce back because the owner was wrong on arrival. Another third stall because whoever received the ticket does not know the right fix path for that specific environment. Those are our own observations across enterprise environments, and every security leader we show them to nods before we finish the sentence. The technical work was rarely the bottleneck. The name was.

Think about what a single bounce actually costs. A finding is triaged, assigned, and sent. Days pass. It comes back marked "not my system." Now it re-enters the queue, gets re-triaged by someone who has lost the original context, gets reassigned to a better guess, and the clock starts over. One finding can make that loop three or four times before it lands on the right desk. None of that time is recorded anywhere as "ownership discovery." It shows up only as a large MTTR and a tired team.

Why the CMDB lies

Ask any organization where ownership lives and someone will point to the CMDB. Then ask when it was last correct.

The uncomfortable truth is that ownership data is stale the day it is entered, and it decays quickly. Enterprises are in constant motion. Teams reorganize. People change roles and leave. Applications get handed from one group to another and the record never catches up. Cloud makes it worse: infrastructure is created and destroyed by automation faster than any human process can document it, and a server that existed this morning may be gone tonight, replaced by three others that no one has labeled. Mergers bolt on whole estates with their own conventions and their own gaps. Teams stand up systems that no central inventory ever sees.

Underneath all of it runs the layer that actually decides outcomes and never gets written down: tribal knowledge. Who used to run that service. Who touched it last. Who will be furious if it goes down during month-end close. Which listed "owner" has not logged in for a year. That knowledge determines whether a fix gets approved, and it lives in people's heads and old message threads, not in a database field. So when a finding needs an owner, someone reconstructs that context by hand, one conversation at a time, and the organization calls it remediation.

An org chart tells you who reports to whom. It does not tell you who can safely reboot a production system at 2 a.m. Those are different questions, and only the second one closes a vulnerability.

The debate outlasts the exposure window

The real cost of MTTO is not time on a report. It is exposure in the real world.

While your organization debates who owns a finding, the attacker's clock is running, and it runs fast. Once inside, attackers move from initial access to lateral movement in an average of 29 minutes, and in one recorded case in 27 seconds (CrowdStrike, 2026). For the exposures that matter most, the gap between public disclosure and exploitation has collapsed toward zero: a median of zero days for the internet-facing edge devices attackers hit first (2026 Verizon DBIR). Every hour spent asking "who owns this?" is an hour of standing exposure you do not get back. Ownership latency is not administrative overhead you can afford to wave off. It is pure, unrecoverable MTTR, and it is frequently the largest slice of the entire number.

This is the part that should make a security leader uncomfortable. The most dangerous window in your program is not the time it takes to write a fix. It is the dead time before anyone is even accountable for writing it. During that window nothing is happening. No one is working the problem. The exposure is simply open. It is the quietest and most expensive failure in exposure management, and it hides in plain sight inside a number you report every month.

No one owned it. So no one fixed it.

Onit exists because of this exact failure. Before starting the company, our co-founder Ofer Amitai lived through a breach that state-sponsored attackers carried out through a single known vulnerability. There was a fix. The flaw was not exotic. It was buried in a backlog no one could reach the bottom of, and it went unclosed for one reason: no one owned it, and nothing drove it to closure.

That is MTTO at its worst. Not a hard technical problem. A known, fixable flaw that sat unowned until an adversary made the ownership question moot. Ownership is not bureaucracy. It is, quite literally, the difference between a vulnerability that gets fixed and one that becomes a breach.

Prioritization does not solve this

The industry's dominant answer to a backlog that never closes has been better prioritization. Score every finding. Add threat intelligence and reachability analysis. Sort the list so the top is the work that truly matters. A whole generation of tools, including most of the newer exposure management platforms, is built on this promise.

Prioritization is useful . It is also not the bottleneck. A perfectly sorted list still does not tell you who owns line one. Reordering the queue changes which finding you look at first. It does not produce the person who can approve the change, and it does nothing about the three-week ownership hunt waiting behind every top-ranked item. You can have flawless prioritization and still lose weeks per finding to MTTO. A better-ordered backlog with no owners attached is still a stalled backlog. It is just stalled in a more defensible order.

There is a deeper trap here. Reordering the list makes a team feel productive while the list itself keeps growing. It refines the experience of triage instead of removing the need for it. And the need for it is the actual problem.

What good vulnerability ownership looks like

The fix is to stop treating vulnerability ownership as a lookup you perform after a vulnerability appears, and start treating it as context you already hold and keep current.

Instead of one stale system of record, picture ownership inferred continuously from live context across everything that genuinely knows something about a system: the asset inventory, identity and access data, ticketing history, deployment metadata, and the communications where real work gets coordinated. Cross-referenced, those signals answer the ownership question far more accurately than any single CMDB field, because they reflect what is true now, not what someone typed a year ago. The finding arrives with the right name already attached.

Then make the ownership decision once, and let it persist. When you establish that a given class of system belongs to a given owner, that becomes an operating rule, not a one-time assignment that rots. As people move and systems change hands, responsibility adjusts on its own rather than reverting to a dead name. The same debate does not reopen every time a similar finding appears, because it was already settled. This is what predefined ownership means, and it is the ownership logic at the center of Decision-Based Exposure Management: a judgment made once that keeps applying itself. It is why we describe the goal plainly: MTTO driven toward zero.

Ownership defined ahead of time changes the shape of the whole program. A finding no longer waits to become someone's problem. It is someone's problem the instant it appears, with the context needed to act already attached. The engineer who receives it is the right engineer, and they receive a fix path instead of a mystery. The bounce-back loop, the single biggest hidden cost in remediation, largely disappears. And the analyst who used to spend the day chasing names spends it approving decisions instead.

Drive MTTO to zero

You cannot fix what you do not measure, and almost no one measures MTTO. It hides inside MTTR, invisible and enormous: the dead time before anyone is accountable. Surface it and you will find it is often the largest and most fixable part of your remediation timeline.

The fastest resolution is the one that already knows whose job it is. Ownership is not a database you clean up once a quarter. It is live context you hold, a decision you make once, and a rule that keeps itself current as your organization changes. Humans define judgment. Agents execute. Decide once. Resolve forever.

Measure MTTO. Then drive it to zero.

See how Onit puts the right owner on every finding, so tickets arrive with a name instead of a bounce-back. Get a demo.

Frequently asked questions

Vulnerability ownership is the assignment of a specific, accountable owner, the person with the authority and context to approve and drive a fix, to a given vulnerability or class of vulnerabilities. In most enterprises ownership is unclear the moment a finding appears, which is why remediation stalls before any technical work begins.

MTTO, mean time to owner, is the time between a finding entering the queue and the right owner taking responsibility for it. It hides inside MTTR and is often its largest component. Up to half of remediation tickets bounce back because the owner was wrong on arrival, and about a third stall because the recipient lacks the context to act (Onit field observations).

Because ownership data is stale. CMDBs, org charts, and asset inventories fall out of date as teams reorganize, people change roles, and cloud infrastructure is created and destroyed automatically. A ticket routed from a stale record lands on the wrong desk, bounces, and re-enters the queue, restarting the clock.

Stop treating ownership as a lookup performed after a vulnerability appears. Infer it continuously from live context across asset, identity, ticketing, and communication data, then make the ownership decision once so it persists as a rule that adjusts through reorgs and system changes. Ownership defined ahead of time drives MTTO toward zero. This is the ownership logic behind Decision-Based Exposure Management.

Get a Demo