AWS Builder Center
ARC Region Switch Closes the Gaps Around Your Failover

ARC Region Switch Closes the Gaps Around Your Failover

Multi-Region failovers rarely break at the traffic shift. They break in the steps around it: a quota nobody raised in the standby Region, an Auto Scaling group that says "scaled" while instances are still booting, a shell script someone has to SSH in and run at midnight.

On October 14, 2026, AWS added four capabilities to Amazon Application Recovery Controller (ARC) Region switch that target exactly those steps:
  1. An AWS Systems Manager Run Command execution block
  1. Payloads for the custom action Lambda execution block
  1. Service quota parity checks between primary and standby Regions
  1. An optional wait for target group health on ECS service scaling and EC2 Auto Scaling group blocks
This post walks through what each one does, the failure mode it removes, and the caveats worth knowing before you build on it.

Region switch in 60 seconds

Region switch is the ARC feature for orchestrating a multi-Region application failover so recovery time stays bounded during a Regional impairment. You describe the failover once, as a plan, and execute it when you need it.
  • Plan: the recovery definition for one application, covering its primary and standby Regions.
  • Workflow: the ordered sequence of steps the plan runs for an activation or deactivation.
  • Execution block: one step in the workflow. Blocks exist for scaling compute, promoting databases, shifting traffic, manual approvals and calling your own Lambda functions.
  • Plan evaluation: Region switch checks the plan against your real resources right after you create or update it, then every 30 minutes, so drift shows up before an incident instead of during one.
The four new capabilities either add new execution blocks or make existing ones safer. Plan evaluation is the thread that ties most of them together.

1. Systems Manager Run Command execution block

What it does. A new execution block invokes AWS Systems Manager Run Command against managed instances and VMs as a step in the failover workflow.
The gap it closes. Most real failovers include host-level work that no managed block covered: restarting an app service so it picks up a new database endpoint, flushing a local cache, swapping a config file, re-registering an agent. Until now that lived in a runbook, a custom Lambda wrapper, or someone's SSH session.
How it is checked. Plan evaluation verifies two things ahead of time:
  • the command documents target valid instances, and
  • the IAM permissions needed to run them are in place.
That matters because the classic failure here is silent: a tag that no longer matches anything, or a role missing  ssm:SendCommand , discovered only when the step runs during the incident.
Benefits
  • Host-level steps become part of the orchestrated, observable plan instead of out-of-band tribal knowledge.
  • No Lambda glue code just to call Run Command.
  • Misconfigured targets or permissions surface during routine evaluation, not mid-failover.
  • Works for anything registered as an SSM managed node, which includes on-premises or other VMs, not only EC2.
Practitioner notes. Targets still need a working SSM Agent and the right instance profile or hybrid activation; evaluation checks the plan, not the agent's health at execution time. Keep the documents idempotent, because a failover you retry should not double-apply a change. And target hosts in the Region you are activating; a step that depends on the impaired Region is a step that may not run.

2. Payloads for the custom action Lambda block



What it does. The custom action Lambda block, the escape hatch for anything Region switch does not model natively, can now pass a payload to your function.
The gap it closes. Without input, every Lambda had to know its context up front. Teams ended up with  failover-orders-dns ,  failover-payments-dns ,  failover-orders-cache  and so on: near-identical functions differing only in a hostname or an ID. Each copy is one more thing to patch, permission and keep in sync.
How it changes the design. Write one generic function and let each plan, or each step, tell it what to act on. An illustrative payload for a shared "update app config" function might look like this:
{
"application": "orders-api",
"parameter": "/orders/prod/db-endpoint",
"value": "orders-db.cluster-xyz.eu-west-1.rds.amazonaws.com",
"notify": "#orders-oncall"
}
The payload keys above are an example of your own contract, not an AWS schema; check the block's documentation for exactly how the payload reaches your handler.
Benefits
  • One function, many recovery plans: less code, fewer IAM roles, one place to fix bugs.
  • Plans become more declarative, since the step's intent sits in the plan rather than hard-coded in the function.
  • Easier to standardise failover tooling across teams on a shared platform.
Practitioner notes. Two existing behaviours still apply. You choose which Region the function runs in, and AWS advises against running it in the Region you are deactivating. And in ungraceful execution mode, Region switch skips this block entirely, so nothing critical should depend on it in a hard-down scenario.

3. Service quota parity checks

What it does. Region switch now compares service quotas between your primary and standby Regions and automatically submits quota increase requests where the standby falls short.
The gap it closes. AWS itself calls quota limits a common failure mode during recovery. The pattern is familiar: production quotas got raised over years of growth, one ticket at a time, in one Region. The standby, especially a pilot-light or warm-standby setup, still sits near default. Everything works until the failover tries to launch production-scale capacity and hits  LimitExceeded .
The Well-Architected Reliability Pillar (REL01-BP04) has long listed "not assessing quota differences between Regions" as an anti-pattern. Until now, the fix was a scheduled script diffing Service Quotas across Regions, if anyone wrote one.
Benefits
  • Quota drift is detected continuously as part of the recovery plan, not in an annual DR test.
  • Increase requests are filed automatically, removing the slowest manual step.
  • Each plan carries its own capacity assumptions, so quota coverage follows the application rather than a separate spreadsheet.
Practitioner notes. "Submits" is the operative word. An automatic request still goes through the normal Service Quotas process, and large or unusual increases can take time or need justification. Treat this as early warning plus paperwork automation, not a guarantee of capacity at failover time. Watch the request status after enabling it, and confirm approvals before your next game day. Also remember that a quota is permission to use capacity, not capacity itself; scarce instance types can still be short in the standby Region.

4. Wait for target group health

What it does. The Amazon ECS service scaling and Amazon EC2 Auto Scaling group execution blocks get an optional setting. With it enabled, the step waits until the newly scaled tasks or instances are healthy in their load balancer target groups before the workflow moves on.
The gap it closes. "Provisioned" and "ready to serve" are different states. An ASG can hit its desired count while instances are still running user data, pulling artifacts or warming a JVM. An ECS service can report running tasks that have not yet passed health checks. If the next step shifts traffic at that moment, users land on capacity that returns 502s, and the failover looks like a second outage.
The docs already note that the scaling blocks do not guarantee the desired capacity is reached. This setting adds the missing gate: the plan proceeds on what the load balancer actually considers healthy.
Benefits
  • Traffic shifts only onto capacity that has passed real health checks.
  • Removes hand-tuned "sleep 300" steps or manual approvals used as a readiness proxy.
  • Your recovery time reflects actual readiness, which makes RTO numbers from game days more honest.
Practitioner notes. It is opt-in, so existing plans do not change until you turn it on. Its value depends on your health checks: a check that only hits a static  /ping  will report healthy long before the app can serve real requests. And waiting adds time to the step by design, so revisit any timing assumptions in your RTO budget.

Putting it together: an example failover plan

Here is how the four capabilities fit into one activation workflow for a typical web app (ECS front end, EC2 workers, Aurora Global Database) failing over from eu-central-1 to eu-west-1:
  1. Before any incident: quota parity checks keep eu-west-1 quotas in line with eu-central-1 and file increases on drift. Plan evaluation, every 30 minutes, confirms SSM targets and IAM permissions still resolve.
  1. Promote data: the Aurora Global Database block promotes the eu-west-1 cluster.
  1. Scale compute, gated on health: the ECS service scaling and EC2 Auto Scaling blocks scale up in eu-west-1, with wait for target group health enabled.
  1. Host-level fix-ups: the SSM Run Command block restarts the worker service on EC2 and on-prem integration VMs so they pick up the new database endpoint.
  1. Shared custom step: one generic Lambda, called with a payload naming this app and its parameters, updates config and notifies the on-call channel.
  1. Shift traffic: the ARC routing control block moves traffic to eu-west-1, now onto capacity that has passed health checks.
Steps 4 and 5 used to be the parts that lived outside the plan. Steps 1 and 3 used to be the parts that failed quietly.

Where to start

If you already run Region switch, adopt these in order of effort versus payoff:
Capability
Effort to adopt
Failure it prevents
Watch out for
Service quota parity checks
Low
Failover blocked by  LimitExceeded 
Requests still need approval; quota is not capacity
Wait for target group health
Low (one setting per block)
Traffic shifted onto unready capacity
Shallow health checks; longer step duration
SSM Run Command block
Medium
Manual host-level steps during incident
Agent health and idempotent documents
Lambda payloads
Medium (refactor)
Lambda sprawl and drift across plans
Skipped in ungraceful mode
The first two are close to free and close the most painful gaps. The other two pay off as you consolidate runbook steps into the plan itself.
All four are available in all commercial AWS Regions and AWS GovCloud (US). The API support landed in the AWS SDKs on September 25, 2026, ahead of the October 14 announcement, so Terraform and CDK coverage should follow your provider's usual release cadence.
The bigger shift is what a Region switch plan represents. With host commands, parameterised custom actions, quota coverage and readiness gates inside it, the plan is closer to a complete, testable definition of how your application fails over. That is the real benefit: fewer things that only work if the right person remembers them at 3 AM.

Sources

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article