Back to Blog
DDoSDDoS FailoverDDoS TestingMulti-RegionResilience

DDoS Failover Testing: Protection, Capacity and Trust Parity at the Second Site

BlackNeuron Research Team
November 19, 2026
13 min read
DDoS Failover Testing: Protection, Capacity and Trust Parity at the Second Site

A failover plan assumes a second copy of the service exists, and copies drift.

The copy was built once, usually carefully, often by the same Terraform module that built the primary. Then the primary kept changing. Rules were tuned, limits were raised, a certificate was reissued, a partner added an allowlist entry, and during the last incident someone added three blocking rules by hand at two in the morning.

The secondary saw some of that. A DDoS failover test is how you find out which parts.

What a DDoS failover test checks

DDoS failover testing runs the move to a second region, site or provider under attack-shaped load and checks that the place the traffic lands is a working copy of the place it left: protected the same way, sized for the flood as well as the users, trusted by everything the service talks to, and carrying the changes made during the incident that caused the move.

How failover itself works (the DNS, routing and provider levers, whether the flood follows, health checks that flap, the way back) is set out on the DDoS failover definition page. What happens when the two places are a cloud and a data centre joined by an interconnect is worked through in hybrid-cloud DDoS testing. This post covers the question both of those leave open: once traffic arrives, is the secondary the same system?

Parity layerTypical gap on the secondaryHow the test sees it
ProtectionResource not enrolled, WAF policy a version behind, rate counters at zeroFlood reaches the secondary origin at rates the primary would have stopped
CapacityRegional quota, scaling maximum, cold caches, no shared TLS ticket keysThe secondary saturates on the users alone, before the flood is counted
TrustCertificate, signing keys, partner allowlists keyed to the primaryErrors on login, payments or outbound calls while the front page looks fine
Incident stateEmergency rules added to the primary in the first hourThe attack that was contained on the primary is uncontained again

Why the copy drifts

Every change has a primary and a secondary version, and only one of them is under daily pressure to be right. The primary carries traffic, so a wrong setting there is noticed within hours. A wrong setting on an idle secondary is noticed when the secondary takes traffic, which is the worst possible moment.

How the second site drifts from the first Both start identical. Only one of them is under daily pressure to stay right. Primary Secondary same build WAF tuning limit raised cert reissued partner allowlist emergency rules IaC change IaC change failover day The secondary is Protection: older Capacity: smaller Trust: links missing Incident: none of it drift runs one way Console edits, managed rule updates, third-party allowlists and incident changes never pass through the shared module. BlackNeuron™
DDoS failover parity drift over time: the primary and the secondary start from the same build, then the primary receives a stream of changes (WAF tuning, raised rate limits, a reissued certificate, a partner allowlist entry, emergency rules during an incident) while the secondary receives only the changes that went through infrastructure as code, so by the day of the failover the secondary differs from the primary in protection, capacity, trust and incident state

Infrastructure as code narrows it, not to zero

Building both sites from one module removes most structural drift. It does nothing for settings that live outside the module: values changed in a console, managed rule versions that update on their own schedule, allowlists kept by third parties, and anything typed during an incident.

Incidents are the biggest source

Under attack, people change the primary fast and by hand, because that is where the attack is. Those changes are the most valuable ones the organisation owns that week, and they exist in exactly one place.

Drift has a direction

The secondary is almost never stricter than the primary. Drift runs one way: the secondary is older, looser and smaller. That makes it a predictable finding, which is why a failover test can be planned around it.

Protection parity

The first question on arrival is whether the flood meets the same controls it met a minute ago. Several common cloud controls are attached per resource or per region, and a failover changes both.

Enrolment is per resource

AWS Shield Advanced protects the resources you add to it, one by one, and its health-based detection uses the Route 53 health checks you associate with each protection. A load balancer created in the secondary region is not covered until someone adds it. Azure DDoS Network Protection is enabled per virtual network, so the secondary region's network has to be linked to the plan as well. The provider-by-provider detail is in AWS Shield Advanced testing and the AWS Shield vs Azure comparison.

WAF policies are regional objects

Outside CloudFront, an AWS WAF web ACL lives in one region, so a secondary region has its own ACL. It is either deployed from the same source as the primary or it has drifted, and a test should read both and compare rule by rule: action, threshold, scope-down, rule order.

Rate counters start at zero

AWS documents that each rate-based rule instance keeps its own counts. A second web ACL with identical settings is a second instance. When the service moves, every source the primary was already limiting arrives at the secondary with a fresh budget. Each one is let through again until it has spent the whole limit a second time, and with thousands of sources that refill is a sizeable burst landing on a cold site.

The flood arrives with a fresh budget A second regional web ACL is a second rate-limiting instance, with its own counters. Flood sources thousands of IPs before after failover Primary web ACL rate counters: over the limit, blocked emergency rules: 3, added by hand region A Secondary web ACL rate counters: 0 for every source emergency rules: none region B, separate instance Flood held at the limit most sources already blocked Every source has a fresh budget passes until it spends the limit again One edge in front of both sites keeps one set of counters and one rule set, so a failover behind it moves neither. BlackNeuron™
Rate limit counters across a DDoS failover: on the primary, sources that exceeded the limit are already being blocked; after failover the same sources reach the secondary's web ACL, a separate instance whose counters start at zero, so every source gets a fresh budget and is let through until it has spent the limit again, while emergency rules added by hand on the primary during the incident do not exist on the secondary at all

Learned baselines do not travel

Controls that learn normal traffic, such as Cloud Armor's Adaptive Protection or a bot manager's per-site model, build their baseline from the traffic the protected service has actually seen. A secondary that has carried no production traffic has no baseline, so the control that alerted on the primary may stay quiet on the secondary for the first hours. How that learning period behaves under test is covered in Cloud Armor Adaptive Protection testing.

The origin lock

The primary origin probably accepts traffic only from the CDN or scrubbing provider, through a firewall rule or the provider's published ranges. The secondary origin was built later, sometimes for a disaster drill where speed mattered more than lockdown. If it answers on its own address, the flood can skip the edge entirely, which is the origin exposure problem with a second address to find.

Capacity parity

A secondary is usually sized for the loss of a data centre, which is a calm event: the users move, nothing else does. A DDoS failover moves the users and, often, the flood. The definition page covers whether the flood follows. The parity question is narrower: can the secondary carry the users alone on a cold start?

Quotas are regional

Cloud service quotas (instances, vCPUs, load balancer capacity units, concurrent executions) are set per region and per account. A scaling group whose maximum fits inside the primary's quota may hit a lower default in the secondary region, and quota increases take hours or days to approve. Capacity reservations exist for exactly this case, and the test checks whether any are held.

Scaling starts from the minimum

A warm standby runs at its minimum size. When traffic arrives, the scaler adds capacity at its configured step and cooldown, and each new instance or pod pays its boot and warm-up time. The secondary serves the first minutes with whatever was running before the move. The autoscaler exposure page covers the window this opens; for failover, the number to record is how long the secondary takes to reach the primary's steady-state size.

Caches start empty

The secondary's caches (CDN tier if it is a separate distribution, application cache, database buffer pool) hold nothing. A request mix that hit the cache 95 percent of the time on the primary sends every request to the origin for the first minutes on the secondary. That is a property of the move, not of the attack, which means the test can measure it without a flood at all.

TLS resumption breaks

Clients resume TLS sessions with tickets encrypted under the server's ticket key. If the two sites do not share ticket keys (in NGINX, ssl_session_ticket_key points at the same key files on both), every resumption fails at the secondary and every client falls back to a full handshake. A full handshake costs the server a certificate signature that resumption skips, so the secondary's TLS terminators take the heaviest per-connection work for every user at once, during the same minutes as a TLS handshake flood if the attacker sends one.

The data that stayed behind

Many designs fail over the application tier and leave the database where it was, because promoting a replica is a separate, riskier decision. The application in the secondary region then reaches back to the primary database across the regions.

That is fine for one query. A request that makes ten sequential queries pays the cross-region round trip ten times, and every one of those milliseconds is a connection held open in the pool.

2026-11-19T07:04:34.669854 image/svg+xml Matplotlib v3.5.1, https://matplotlib.org/ 0 10 20 30 40 50 60 Time (seconds) 0 20 40 60 80 100 120 Database connections in use pool cap: 100 failover: each query crosses regions 300 rps, 10 queries per request, pool cap 100. Model, not a measurement. Failing over the app tier without the database connections in use BlackNeuron™
Model of a database connection pool on a failed-over application tier: at 300 requests per second and 20 ms per request in region, about 6 connections are in use; after the failover, ten sequential queries each crossing a 70 ms round trip hold each connection for about 0.7 s, so demand rises to about 210 connections and the pool pins at its cap of 100

The arithmetic is Little's law: connections in use equal the request rate times how long each request holds one. At 300 requests a second, 20 ms in region means about 6 connections. Ten queries at an illustrative 70 ms round trip mean about 0.7 s per request and about 210 connections wanted, so a pool of 100 pins at its cap and the rest queue. No attack traffic is needed for this; real users are enough.

Trust parity

Some failures after a failover never show on a status page. The front page loads and the health check passes, while login, payment or a partner integration fails, because something outside the service trusted the primary specifically.

Up, and still not working Four things outside the service trusted the primary specifically. Secondary region front page: loads health check: passing Certificate regional, issued separately expired or never issued here Session and token keys differ between sites every user logged out at once Partner allowlists list the primary's egress IPs outbound calls refused Inbound webhooks set to the primary's address still delivered there None of these show on a status page. The test calls each one by name from the secondary. BlackNeuron™
Trust parity after a DDoS failover: the secondary region's front page and health check succeed, but four trust links that point at the primary fail: a regional certificate that was never issued or has lapsed in the secondary, session and token signing keys that differ so every user is logged out, partner and payment allowlists that list only the primary's egress addresses so outbound calls are refused, and inbound webhooks still configured to deliver to the primary

Certificates are regional too

AWS Certificate Manager certificates belong to one region, and a load balancer can only use a certificate from its own region (CloudFront, the exception, uses certificates from us-east-1). The secondary needs its own certificate, issued and validated separately, with its own renewal. A failover test reads the expiry date on the secondary, not the primary.

Signing keys

If sessions or tokens are signed or encrypted with keys that differ between sites, every user who arrives at the secondary holds a token the secondary cannot verify. Everyone is logged out at once and everyone logs in at once, on top of whatever brought the primary down. How that stampede behaves for app clients is covered in the mobile backend post, and for remote-access tunnels in VPN gateway DDoS testing.

Allowlists you do not control

Outbound calls from the secondary leave from different addresses: the secondary region's NAT gateways have their own public IPs. A payment provider, a bank partner or a B2B customer that allowlists your egress addresses will refuse the secondary until someone emails them, and that list is kept in someone else's system, outside any of your code.

Inbound hooks

Webhooks, callbacks and file drops from partners are often configured with a hostname, sometimes with an address. Those configured with the primary's address keep delivering to the primary after the move, and the test checks each one by name.

What the first hour changed

The changes made during an incident deserve their own section, because they are the reason the failover is happening at all.

By the time someone decides to fail over, the team has usually spent an hour fighting the attack on the primary. They have added address blocks, geography rules, tighter rate limits, a challenge on the login path, a header match for the attack tool's fingerprint. Some of it is working. That is often exactly when traffic leaves the primary for a site that has none of it.

Mirror the emergency layer

Two designs keep this layer in sync. One is a single rule set evaluated before both sites, which is what a global edge or a scrubbing provider in front of both gives you. The other is an emergency rule group deployed from one source to both sites, which responders edit instead of either site's console. The DDoS runbook is where that procedure is written down.

Test it as part of the failover

The test reproduces the sequence: run the flood against the primary, add a set of emergency rules there the way responders would, then fail over and check whether those rules are in force on the secondary. If they are not, the record should say how long it took to re-add them by hand. Rehearsing who decides to fail over, and when, is a tabletop exercise question; this step measures what the decision costs once it is taken.

Running a failover parity test

A parity test has three stages, and only the last one needs the flood. The planning, authorisation and abort rules shared by every DDoS test are in the complete guide to DDoS testing.

A failover parity test, in three stages Only the last stage needs a real failover. 1. Diff the two sites no traffic WAF rules and actions enrolment, origin rules quotas, scaling limits certificates, key IDs NAT egress addresses 2. Test the secondary alone no failover real user mix first then the flood gives its own ceiling separates "too small" from "the move went wrong" 3. Fail over under load flood running emergency rules on primary trigger as on the day rules in force on arrival? time to steady size trust links, by name Stages 1 and 2 find most of the drift, and cost a fraction of a full failover. BlackNeuron™
DDoS failover parity test in three stages: first a configuration diff of the primary and the secondary across protection, capacity, trust and incident state, with no traffic; second a direct test of the secondary on its own with the real user mix and then the flood, before any failover, so its ceiling is known; third the failover itself under attack-shaped load, with emergency rules added on the primary beforehand, recording what was in force on the secondary, how long it took to reach steady size, and which trust links failed

Stage 1: diff the two sites

Export both sites' configuration and compare them: WAF rules and actions, rate thresholds, protection enrolment, origin firewall rules, scaling limits, quotas, certificates and their expiry, key identifiers, NAT egress addresses. This stage costs nothing and finds most of the drift.

Stage 2: test the secondary on its own

Before any failover, send the real user mix and then the flood straight at the secondary, as if it were the primary. This gives the secondary's own ceiling, and it separates "the secondary is too small" from "the move went wrong". A secondary that cannot carry the users alone will not carry them during an incident.

Stage 3: fail over under load

Then run the whole thing: flood on the primary, emergency rules added there, failover triggered the way it would be on the day, flood still running. The stage timings come from the definition page; the parity checks below come from this post.

CheckHow the run measures itPasses when
Protection on arrivalFlood rate reaching the secondary origin in the first windowAt or below the primary's rate under the same flood
Emergency rulesRules added on the primary, read back on the secondaryPresent on arrival, or re-added within the agreed time
Users aloneReal user mix sent to the secondary with no floodServed within the latency target from a cold start
ScalingTime from failover to the primary's steady-state sizeWithin the time the runbook assumes
Cross-region dataConnection pool use and latency on the secondary app tierPool below its cap at the expected request rate
Trust linksLogin, payment, partner calls and webhooks, by nameEach succeeds from the secondary

FAQ

What is DDoS failover testing?

It is running a failover to a second region, site or provider during attack-shaped load, and checking that the destination is a working copy of the origin site: protected the same way, able to carry the traffic, trusted by the services it depends on, and carrying the emergency changes made during the incident.

How is it different from a disaster recovery drill?

A DR drill usually moves calm traffic after a simulated loss of a site. A DDoS failover test moves traffic while a flood is running, often while the flood can follow the move, and it checks the controls that only matter under attack: rate counters, protection enrolment, WAF policy parity and emergency rules.

Do rate limits carry over when traffic fails over?

Usually not. Where the secondary is a separate rate-limiting instance, as with a second regional AWS WAF web ACL, its counters start at zero, so sources that were already limited on the primary get a fresh budget. A single global edge in front of both sites avoids this, because its counters do not move.

Can the secondary be tested without failing over?

Yes, and it should be first. A configuration diff needs no traffic, and the secondary can be load-tested directly as if it were the primary. Only the last stage, the move under load, needs a real failover.

The secondary is a snapshot

Everyone who builds a second site builds it to be identical, and on that day it is. After that it becomes a snapshot of the primary from some earlier date, and the date gets older with every change that was made on one side only.

Some things about failover hold for years: controls attached per resource stay behind when the resource changes, counters belong to the instance that keeps them, trust is granted to addresses and keys, and the changes made under pressure go wherever the responders were standing. The specific gaps (a rule, a quota, a key, an allowlist) change every month.

A failover test does not prove the second site works. It reads the date on the snapshot.