Logo
Logo

The Empty Queue

Vriti Magee | Nov 15th 2026

IMG_2026-11-13-123728.jpeg

"Built to the blueprint. Served from an empty queue." Illustrated by DALL·E

Several years ago, I was asked a simple question by a critical-infrastructure organisation partway through their move to the cloud. They ran more than a thousand applications, around a hundred of them critical.

After a cyber outage, how many of those hundred would customers actually be able to use?

Disaster recovery had been handed to a managed service provider. So we asked for evidence, and evidence arrived. Terraform scripts in one repository. Excel workbooks in another, row after row attesting that tests had been performed and applications restored. Screenshots, neatly cropped. Assurances, delivered with confidence.

What never arrived was proof. No one could show us what any application was actually made of, what it depended on, or that it had ever come back whole. The board paper was written, rewritten, and never quite made it to the boardroom. It is still the one that got away.

I thought of that evidence pack often while getting my own hands on Dreeze, a platform built for exactly this problem.

Intent Versus State

The usual objection comes fast: we have infrastructure-as-code, so why do we need anything else? It is a fair question, with an answer most organisations never consider.

Terraform is declarative. It describes what should exist, and it is superb at deploying it in a forward motion. Backup is something else entirely: a record of what was actually running at a specific point in time. One is intent. The other is state.

"Infrastructure as code deploys an empty queue. Backup brings back the one you had with the messages in it."

The queue is a tidy metaphor for the whole estate. The code can rebuild the shelves. Only a backup can put the stock back on them.

Why the Code Cannot Carry the Recovery

Infrastructure-as-code was never built to be a recovery mechanism, and the reasons are refreshingly plain.

Coverage.

Some of the estate was never declarative to begin with. Not everything gets written as code.

Drift.

The part that is declarative is always drifting from what is running. More coverage is a fine thing, but it is not a recovery strategy.

Sequencing.

No organisation has one Terraform file. It has dozens, owned by different teams, and nothing knows the order in which to run them.

Timing.

Recovery needs every layer aligned to one point in time. Those commits were made by different teams across the past month.

Blast radius.

The repository and the pipeline may be compromised or unavailable themselves. Attackers have a talent for finding the maintenance window.

"Commit is not a restore point."

The drift gap is structural, not a matter of hygiene. Which is a polite way of saying that tidier code will not save you.

Where Terraform Still Earns Its Keep

None of this makes the code worthless. Its authors have already declared which resources belong together, which makes it a rich input for working out what an application actually is. And after a recovery, the rebuilt environment is reconciled back with the code, so nobody is handed a revived application with a broken deployment pipeline.

The code informs the recovery. It just does not get to be the recovery.

🛠️ Architectural View: A Backup You Can Read

Terraform, reverse-engineered.

Live resources are converted into Terraform generated from what is running, not from what a repository says should be running.

Legible by design.

Per resource: configuration, variables, outputs and the raw API response, with hardcoded values hoisted into variables. No proprietary blob.

Replayable.

The provider version is captured with the backup, so an old backup replays with the provider it was written for.

Self-sufficient vault.

Data, metadata and the recovery plan sit together in an immutable vault in the customer's own account, encrypted with keys the customer controls.

A graph, not a guess.

Recovery runs in dependency order. Each step fires the moment its dependencies complete; a failure skips only its dependents.

Room for the unusual.

Custom steps, via webhooks, before or after any resource or application.

Under My Own Login

I walked through the platform end to end: discovering resources, creating backup plans, setting up test plans and restoring.

It starts with a scan. Every account is swept and every resource lands in one flat inventory: queues, keys, functions, databases, roles, whatever lives there. Resources are then classified into the applications they serve, drawing on tags, code and the environment itself.

Then comes the dependency map. An application first looks innocent enough: a database, a couple of buckets, a few functions. Expand it, and expand again, and it becomes what it always was, a dense web of resources with every line a dependency. From there the map is flipped into something that runs: the order in which to bring things back, kept current rather than written once and left to fade.

The dependency mapping is the golden starting point. It is the artefact my evidence pack never contained, and the one every other claim should have rested on. Backup plans, test plans and restores build on it, and the rest is quite brilliant.

Closing Reflections

That old evidence pack was not short of artefacts. It had scripts, workbooks and screenshots in abundance. What it lacked was a single source of truth about what each application was, what it needed, and whether it had ever come back. Assurance is cheap. Evidence is not.

Terraform tells you what you meant to build. Recovery needs what you actually had, messages and all. Dreeze's own banner puts it in three words:

back means back.

Which leaves a question for every architect with a repository full of good intentions:

if the pipeline went down with everything else tonight, how much of your estate would come back as an empty queue?

🔍 Links for Further Reference

Watch the full Cloud Field Day 26 sessions:

Recent Articles