Your disaster recovery plan is a PDF. It was last updated 18 months ago. It references three deprecated services, two engineers who have left the company, and a runbook step that no longer works because the portal has been redesigned twice since.

This is not a technology problem. It's an architecture problem, and the same discipline that turned infrastructure into code can turn disaster recovery into code. We call it DRaaC: Disaster Recovery as Code.

In this session, we'll walk through a working DRaaC implementation built on Azure DevOps or GitHub Actions:
Ppipelines that scan your subscriptions on every PR, exports the live state, generates DR-ready Bicep for a secondary region, detects drift, and posts a structured compliance report directly on the pull request.

The interesting part is what happens around it. We'll cover the forward loop, where code merges trigger DR deployments, and the reverse loop, where portal changes get reverse-engineered back into the repo and into the DR region automatically.

The reverse loop is where agents earn their place: taking lossy decompile output and shaping it into clean Bicep that matches your repo conventions, then opening a PR that re-enters the forward loop like any other change.

We'll be honest about the hard parts: the reserved Azure subnet names that break naive transformation, the resource types that don't export, the data-plane replication that Bicep can't touch, the traffic routing that "near-zero downtime" actually requires.

And we'll be clear-eyed about agents: where they belong (contextual reasoning, refactoring), where they don't (as primary security scanners), and how to scope their autonomy so they help instead of haunt.

You'll leave with a clear architectural pattern, a list of the constraints to design around, the open-source pipeline that implements it, and a frank view of what's solved versus what still needs human judgement.

Your disaster recovery plan is a PDF. It's outdated, it's untested, and it's the wrong shape for a world where everything else is code. This session shows a working pattern for treating DR as a code artefact: Pipelines where pull requests deploy DR alongside production, portal changes reverse-engineer themselves back into the repo, and AI agents handle the contextual work humans used to do at 3am. With the open-source implementation, the constraints, and the honest limits.