Severe-but-Plausible Game Days Mapped to DORA and CPS 230 Scenarios

Both DORA and CPS 230 tell you to test severe-but-plausible scenarios. Neither tells you how, and that gap is where most resilience programmes quietly settle for a meeting with a slide deck instead of an injected failure with a stopwatch on it.

A tabletop exercise where people talk through what they would do if the primary database vanished proves that they can talk. It does not prove the failover works, that the runbook is current, or that recovery lands inside the tolerance the board signed off. Supervisors have started to notice the difference. This is a playbook for closing it: translating the scenario language in the regulations into concrete fault injections, running them against live systems, and measuring actual recovery against the numbers you have committed to.

What the two regimes actually ask for

APRA’s CPS 230 commenced on 1 July 2025, with transitional relief for non-significant institutions that has since expired. Paragraph 28 requires an entity to undertake scenario analysis to assess the impact of severe operational risk events and test its operational resilience. Paragraph 36 requires a tolerance level for each critical operation, expressed three ways: the maximum period of disruption the entity would tolerate, the maximum extent of data loss it would accept, and the minimum service level it would maintain while operating on alternative arrangements. Those are recovery-time and recovery-point objectives in prudential language.

DORA, which has applied since 17 January 2025, comes at the same problem from the ICT side. Article 24(6) requires that appropriate tests be conducted at least yearly on all ICT systems and applications supporting critical or important functions. Article 25 lists the testing methods in scope, and the list is broad: vulnerability assessments and scans, network security assessments, source code reviews where feasible, scenario-based tests, performance testing, end-to-end testing and penetration testing among them. Article 26 layers threat-led penetration testing on top, at least every three years on live production systems, for the entities competent authorities identify. The business-continuity chapter carries the recovery objectives that the testing is supposed to validate.

Read together, the two regimes say the same thing in different dialects. Define a severe-but-plausible disruption to a named critical function, state the recovery you will tolerate, then demonstrate — not assert — that you meet it.

Why the tabletop earns nothing

The tabletop is popular because it is safe, cheap and calendarable. It is also evidence of a conversation and nothing more. When a supervisor asks how you know your payments function recovers inside its tolerance, “we discussed it and the team was confident” is not an answer. The failure modes that break real recovery are precisely the ones a discussion never surfaces: the failover script that references a decommissioned host, the replica that was lagging further behind than anyone believed, the runbook step that assumes an engineer still has credentials she lost in the last access review.

A game day is the opposite. You inject an actual fault into a real system, on a schedule and inside a controlled blast radius, and you measure what the system and the people around it do. The output is not a set of notes. It is a recovery time, a data-loss figure, and a clear verdict on whether either breached the tolerance. That is the artefact both DORA and CPS 230 are ultimately reaching for, and it is the one described in more depth in our reading on operational resilience testing and impact tolerances.

Translating scenario language into a fault

The translation step is where most programmes stall, because regulatory scenario text is deliberately abstract. “Loss of a critical third party” or “unavailability of a core processing system” is a category, not a test. The job is to reduce it to a specific, reversible fault you can actually cause.

  • Loss of primary datastore becomes: sever the application’s network route to the primary database instance and time the failover to the replica.
  • Critical cloud region failure becomes: fail health checks in one region and observe whether traffic shifts and state reconciles within tolerance.
  • Key third-party API outage becomes: return errors or inject latency at the egress boundary to that provider and watch the circuit breaker and fallback behave.
  • Ransomware-style data corruption becomes: restore a critical dataset from backup into an isolated environment and measure the recovery point achieved.

Each of these maps cleanly onto a named critical operation and its stated tolerance. The scenario library from which you draw them is worth maintaining deliberately rather than inventing per exercise; we set out how to build one in the CPS 230 severe-but-plausible disruption library.

The runbook, as code

A game day needs a harness that injects the fault, times the recovery, heals cleanly, and writes evidence in a form you can hand to an auditor. The script below does exactly that for the datastore-loss scenario. It is deliberately small: the point is that the tolerances are declared explicitly, the fault is real, and the verdict is computed, not asserted.

#!/usr/bin/env bash
# game-day.sh - severe-but-plausible fault injection with measured recovery.
# Scenario: primary payments datastore becomes unavailable.
# Captures RTO/RPO against the declared tolerance and writes evidence JSON.
set -euo pipefail

SCENARIO="payments-primary-db-loss"
CRITICAL_OP="payments"
# Tolerances taken from the resilience framework (CPS 230 para 36 / DORA BCP).
RTO_TOLERANCE_SECS=1800   # 30 min: max tolerable period of disruption
RPO_TOLERANCE_SECS=60     # 60 s: max acceptable data loss
EVIDENCE="evidence/${SCENARIO}-$(date -u +%Y%m%dT%H%M%SZ).json"

probe() {  # 0 when the critical operation is serving; used to time recovery.
  curl -fsS --max-time 5 https://health.internal/payments/ready >/dev/null 2>&1
}

inject() {  # A real fault, not a discussion: drop the app-to-primary route.
  echo "[inject] blocking primary datastore route"
  sudo iptables -I OUTPUT -d "$DB_PRIMARY_IP" -j DROP
}

heal() {    # Restore the route once failover/operator recovery has completed.
  sudo iptables -D OUTPUT -d "$DB_PRIMARY_IP" -j DROP || true
}

trap heal EXIT
t_start=$(date -u +%s)
inject
until probe; do
  elapsed=$(( $(date -u +%s) - t_start ))
  if [ "$elapsed" -gt "$(( RTO_TOLERANCE_SECS * 2 ))" ]; then
    echo "[abort] no recovery within 2x tolerance; halting game day"; break
  fi
  sleep 5
done
t_recovered=$(date -u +%s)

rto_actual=$(( t_recovered - t_start ))
# RPO derived from replication lag sampled at the moment of failure.
rpo_actual=${REPLICATION_LAG_SECS:-unknown}
breach=false
[ "$rto_actual" -gt "$RTO_TOLERANCE_SECS" ] && breach=true

mkdir -p evidence
cat > "$EVIDENCE" <<JSON
{
  "scenario": "$SCENARIO",
  "critical_operation": "$CRITICAL_OP",
  "executed_utc": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
  "rto_tolerance_secs": $RTO_TOLERANCE_SECS,
  "rto_actual_secs": $rto_actual,
  "rpo_tolerance_secs": $RPO_TOLERANCE_SECS,
  "rpo_actual_secs": "$rpo_actual",
  "tolerance_breached": $breach
}
JSON
echo "[evidence] wrote $EVIDENCE (breach=$breach)"

The mechanics vary by estate — a Kubernetes cluster wants a pod-kill or network-policy fault rather than an iptables rule, and a managed database wants a forced failover through the provider API. The structure does not vary. Declare the tolerance, cause the fault, time the recovery, compute the verdict, keep the file.

Measuring against the number, not the mood

The discipline that separates a game day from a stunt is that the tolerance is fixed before the exercise and the verdict is arithmetic. A recovery of thirty-one minutes against a thirty-minute tolerance is a breach, and a breach is a finding, not a footnote. That honesty is the whole value. It is far cheaper to discover in a controlled Tuesday-morning exercise that failover takes twice as long as the board believes than to discover it during the real incident, with a reporting clock running and a supervisor waiting.

The evidence file is what changes the board conversation. Instead of a status of green because nobody has tested otherwise, the report carries a scenario, a date, a measured recovery time, a measured data-loss figure, and a pass-or-breach against each critical operation’s tolerance. That is the reporting substance DORA now expects to reach the management body — a shift we set out in how DORA changes board reporting — and it is the proof-not-policy posture that CPS 230 was written to force, which we cover in our reading of CPS 230 as a proof standard.

What a supervisor will ask to see

On the day of an engagement, the credible answer to “how do you know you meet your tolerances” is a folder of these evidence files, one per critical operation, dated, with the faults described, the recoveries measured, and the breaches tracked to remediation and re-tested. The incredible answer is a scenario-analysis policy and a set of tabletop minutes. The regulations have converged on demanding the first. The programmes that only produce the second are the ones that will be found out, either by an examiner or by an outage.

Run the game day. If the failover takes longer than the board thinks, you want to be the one who found out first.

Sixteen Pillars is a technology governance consultancy based in Cyprus. Engagements run remote across the EU, UK, and Middle East, with on-site time where the engagement requires it.

Free interactive tool

Website compliance checklist

What your site has to do, based on what it actually does

Answer as much or as little as you like — the list builds as you go. Nothing is stored against your name and no email is required.

Free interactive tool

Interactive deadline calculator

Check which regulations apply to you and when

Regulation across the EU, UK, US and Asia-Pacific has moved considerably in the past eighteen months, and several headline dates have shifted more than once. Twelve questions, about three minutes.

Results are shown on screen — no email required. A dated summary is available to download, and can be sent on if that's more useful. What we do with your answers.

Most technology problems are not technology problems. They are control problems.

The systems exist. The investment has been made. The question is whether leadership can understand, direct, evidence, and sustain what those systems produce. Find out where control exists — and where it only appears to.

Full Governance by Sixteen Pillars

Govern your business. Prove your compliance.

A board assurance cockpit for EU-regulated financial firms — tamper-evident, hash-chained proof of governance across DORA, GDPR, NIS2, ISO 27001, the EU AI Act and MiCA. In development.

See what's coming