RELEASE #091 · NOV 19, 2026 GRC ENGINEERING · 9 MIN READ

⚙️ The Most Useless Controls You Own Are A.5.29, A.5.30 and A1.3

One tabletop, one PDF, one annual RTO check. None of it has ever helped anyone recover. See how GRC Engineering can help you square the circle.

Pixel-art scene: a server rack on fire at night. An engineer in a teal hoodie fights the flames with an extinguisher while the copper GRC robot helpfully holds out a thick binder stamped with a green tick.

Last Friday I was at SFO with a boarding pass for London when the FAA stopped every departure in the country.

What caused it was surprisingly mundane: a telecoms outage at air traffic control. That was enough to stop one of the busiest aviation systems in the world, and I spent a few hours waiting while other people lost their flights entirely.

Somewhere in that system there is a continuity plan for exactly this, and I'd bet it passed its last review.

That thought stuck with me, because I've written those plans. I've run the tabletops and I've had the PDFs, and they didn't do crap.

The ritual that always passes

The way most companies do BCP/DR is simple. There's one tabletop a year, one process written up in a PDF, and one annual check that the restore numbers (the SLA, the SLO, the RTO and the RPO) are still written down.

On paper that single ritual covers four controls, and it always passes the audit:

Control

What you hand the auditor

What it proves

ISO 27001 A.5.29, security during disruption

The BCP PDF

A plan was written

ISO 27001 A.5.30, ICT readiness for continuity

Tabletop minutes

People can discuss a scenario

SOC 2 A1.2, recovery infrastructure

"Backup job: success"

A job ran

SOC 2 A1.3, recovery plan testing

The same tabletop minutes

The same thing, again

It maps to all the right controls, and none of it delivers the security or business value it was supposed to. And that value was the only reason anyone wanted it in the first place.

The strange part is that the controls themselves ask for more. A.5.30 says ICT readiness should be tested, and A.8.13 says backups should be regularly tested. The annual ritual is just how most of us tick those boxes.

What happens at 1am

We had a real availability zone outage once, and nobody opened the PDF.

An infra engineer got paged at 1am and did what any good engineer does at 1am: worked from the incident management tool, ran the infra playbook, performed the rollbacks that mattered, and went through the retro and root cause with the team once the fire had settled. Reading a document the GRC team had put together was never going to be part of that night, and I don't think it should have been.

The plan GRC maintains and the plan that runs at 1am are two different documents. The first was written for the auditor, so the auditor is its only reader.

Diagram: two loops that never touch. What GRC maintains: BCP in a PDF, annual tabletop, audit pass. What runs at 1am: AZ outage, on-call paged, infra runbook and rollbacks, service restored, retro and root cause. A dotted line marks the evidence GRC never collects.

Why a control this disconnected keeps passing

I think it comes down to where security looks.

Security lives the CIA triad in order, with confidentiality first, integrity second and availability somewhere after that. The business reads it the other way round. If customers can't log in, nobody asks whether the data was encrypted at rest (which, sitting in a hyperscaler somewhere, has very limited assurance impact on your company anyway, but that's a tangent).

Availability is the cornerstone of a company running, which makes it strange that it's the letter we prove least.

Part of the answer is ownership. GRC technically owns most of BCP/DR, because SRE, infra and platform teams think about reliability in very different terms. They have SLOs, on-call rotations and incident reviews, and they rarely call any of it continuity.

So the plan ends up with GRC, and GRC runs it in the language it knows, which is the language of audits.

Half your RTO belongs to someone else

Back to Friday for a second. The failure didn't happen at the airlines. It sat several layers below them, in the telecoms behind air traffic control, and everything above it stopped.

Your company works the same way. Your RTO assumes your cloud provider, your identity provider and your payment processor all recover inside it too. That's why BCP/DR done properly is half TPRM.

But the vendor review asks whether they have a BCP. It almost never asks when they last restored, how long it took, or whether your data was in scope. So your recovery plan sits on top of other people's PDFs.

Ops already solved this once

Last year I wrote that SREs measure what users actually experience, while GRC teams measure whether documentation exists. One of the pre-SRE "operations theatre" metrics on my list was "whether backups completed successfully."

That's still the core evidence in most DR controls. Ops moved past it twenty years ago, once it accepted that perfect systems don't exist and that what you can engineer is predictable failure and fast recovery.

If GRC ever gets its SRE moment, I suspect DR is where it should start, because it's where trying costs least. Phil Venables made the wider case in Control Reliability Engineering.

The evidence is already in your incident tool

You already have most of the evidence. It's just not where GRC looks.

Every incident your company has had, and every retro after it, records exactly what your DR controls claim to want: what failed, when it failed and how long it took to come back. Your incident tool timestamped every outage last year. Export them, put the RTOs from your BCP next to them, and the gap shows itself:

// rto-check.ts: measured recovery time vs the RTO in your BCP
type Incident = { service: string; startedAt: string; resolvedAt?: string };
const rtoMinutes: Record<string, number> = { checkout: 60, auth: 30, api: 120 };

const incidents: Incident[] = await Bun.file("incidents.json").json();

for (const i of incidents) {
  const rto = rtoMinutes[i.service];
  const took = (Date.parse(i.resolvedAt ?? "") - Date.parse(i.startedAt)) / 60_000;
  const verdict = Number.isNaN(took) ? "UNRESOLVED: finding"
    : rto === undefined ? "NO RTO: finding" : took > rto ? "BREACH" : "ok";
  console.log(`${i.service.padEnd(9)}${Number.isNaN(took) ? "?" : Math.round(took)}m vs RTO ${rto ?? "?"}m  ${verdict}`);
}

A service that blew its RTO in a real outage is a finding. A service that went down and has no RTO at all is a bigger one. Your annual review has seen neither, because it never looks past the PDF.

There's a catch, though. Your incident history only covers the outages you survived. The region loss or ransomware event you're actually planning for has no timestamps, which is exactly why the real restore matters.

So pick the one service the business would notice first and run a real restore. If you can't run it at all, that's the finding, and it's a more honest one than a restore check that passes for eight quarters without ever being able to see a failed restore.

My delay on Friday was a few hours. Other people lost the whole trip.

The useful question about your DR controls is whether, for each critical service you own, you know which of those two you'd be.

Ayoub

That’s all for this week’s issue, folks!

Next releases

Don't inherit someone else's guardrails.

ONE RELEASE A WEEK · FREE · NO VENDOR FLUFF