Every platform on the market treats risk as either an audit object or a security object. Neither is what a risk leader needs — and the gap between them is where most risk programs quietly fail.
Unpatched upstream dependencies could enable remote code execution, exposing customer data.
OWNER d.okafor · MITIGATEWhat risks do we actually have?
Not what each system says separately. The reconciled answer.Which of them can we trust?
Current, owned, corroborated — or none of the above.What should leadership decide?
With the cost, the trade-off, and the objective it threatens.Everyone wants to measure risk in financial terms. Almost nobody can agree on what they're measuring first.
The last decade of risk management has been a quantification argument. Move off heat maps. Express exposure in dollars. Give the board a number it can act on. The argument is correct, and the methods are sound.
But quantification assumes you have inputs. In practice, the input is contested before anyone reaches for a model.
A mid-size organization runs three GRC platforms, a vulnerability scanner, two ticketing systems — one on-prem, one in the cloud — and somewhere between four and forty spreadsheets nobody will admit to owning. Each defines risk differently. Each scores on its own scale. The same underlying condition appears in four of them, under four names, with four severities that don't reconcile.
Ask what the organization's top ten risks are and you will get a different answer from every system. Not a slightly different answer. A different list.
You cannot measure what you have not agreed on.
The usual response is to consolidate — pick a platform, migrate everything, declare it the system of record. This is a two-year program that fails for a predictable reason: the systems that disagree exist because different functions need different things from them. Security is not going to stop using the scanner. Audit is not going to abandon its working papers. Consolidation asks people to give up tools that work for them in service of a reporting layer that benefits someone else.
There is a deeper issue, and it's the one nobody solves because it doesn't look technical.
Nobody agrees on what counts as a risk versus an issue versus a finding versus a gap versus a control deficiency. Every organization has this argument. Most have it repeatedly, in different committees, without resolution.
This persists not because the distinction is hard to define. It persists because the label is political. Calling something a risk triggers ownership assignment, formal acceptance, capital allocation, and board visibility. Calling it a finding triggers a remediation SLA and an owner who resents you for it. Calling it a gap triggers nothing at all.
People select the word that produces the consequence they are prepared to live with. That is a rational response to how these programs are structured, and no amount of taxonomy training will change it.
The way out is not a better definition. It is to stop forcing one — record what was actually observed, then let each function view it through its own lens.
One record underneath. Audit sees a finding. Security sees a vulnerability. The board sees an exposure. The argument about what to call it stops mattering, because nothing downstream depends on winning it.
Not a list of deficiencies. A picture of where confidence is high, where it is declining, where it is falsely assumed, and where there is no basis for confidence at all.
That third category is the dangerous one, and it is invisible to any system holding only its own version of the truth. A risk owned by someone who left eighteen months ago reads as governed — there is a name in the field. A register reviewed annually reads as current on the day it reaches the board. Four systems disagreeing on severity presents as a single number once someone picks one.
This is not a new methodology. It is closer to plumbing — the unglamorous prerequisite that has to exist before the sophisticated work has anything reliable to stand on.
Signal Risk Group advises on the problems above — how risk data is structured, how risk programs are organized, and whether the platforms in place can support what leadership is asking for. Engagements are small, senior, and scoped to a decision rather than a deliverable.
How risk is defined, owned, escalated, and decided across functions that don't naturally agree.
Selection, implementation review, and honest assessment of whether the platform is the problem — often it isn't.
What your register actually contains: staleness, duplication, cross-system disagreement, and gaps in ownership.
Advisory work keeps arriving at the same wall: the reconciliation has to happen somewhere, and doing it by hand doesn't survive contact with a real environment.
So we're building it. Software that reads risk data from the systems you already run, resolves duplicate and conflicting records into one register, and sends the result wherever decisions actually get made — a board deck, a Slack channel, or back into the platform you already own.
Every conclusion traces to the source records that produced it. The software proposes; a named person decides. Not a GRC platform, not a system of record — a layer underneath the ones you have.
In development · working with a small number of design partners