AWS describes four disaster recovery strategies: backup and restore, pilot light, warm standby and multi-site active/active. They trade cost and complexity for faster recovery. For most startups the right answer is backup and restore done properly: Multi-AZ inside one region, immutable backups copied to a separate account and region, and a restore you test on a schedule. Pilot light is worth it for the one or two systems where hours of downtime would really hurt.
The rest of this post is the order we work in: set RPO and RTO per system, pick a strategy for each, build the backups, prove they restore, and write it down on one page.
RPO and RTO: decide them per system, not per company
RPO (recovery point objective) is how much data you can afford to lose, measured in time. RTO (recovery time objective) is how long the system can be down before it seriously hurts the business. Set both per system, because your payments database and your internal analytics do not deserve the same budget.
A short workshop with the founders and the team lead is enough. For each system, ask three questions: what breaks for customers if it is down, what does an hour of lost writes cost (refunds, re-entry, legal exposure), and who would notice first. Then put every system in one of three tiers.
| Tier | Typical systems | Starting RPO / RTO | Usual strategy |
|---|---|---|---|
| Tier 1 | Core transactional database, auth, payments flow | Minutes / under an hour | Multi-AZ plus point-in-time recovery; pilot light in a second region if a region outage is in scope |
| Tier 2 | Main application, APIs, background workers | Hours / a few hours | Backup and restore, infrastructure as code ready to redeploy |
| Tier 3 | Analytics, internal tools, staging | A day / a day or more | Daily backups, restore on demand |
These are starting points to argue with, not standards. What matters is that the numbers are written down, agreed by management, and then tested. An RTO nobody has measured is a guess.
The four AWS disaster recovery strategies
The AWS disaster recovery whitepaper ranks the strategies from cheapest and slowest to most expensive and fastest. Its own summary puts recovery at hours for backup and restore, tens of minutes for pilot light, minutes for warm standby and near real time for active/active.
| Strategy | What runs in the recovery region | RPO / RTO (AWS whitepaper) | When it fits a startup |
|---|---|---|---|
| Backup and restore | Nothing; backups are copied there and infrastructure is redeployed from code | Hours | The default for almost everything |
| Pilot light | Data is replicated continuously (for example an RDS cross-region read replica); app servers are defined but not deployed | Tens of minutes | Tier 1 databases when a region outage must be survivable |
| Warm standby | A scaled-down but working copy of production that can take traffic immediately | Minutes | Rare at seed or Series A; usually driven by a customer contract |
| Multi-site active/active | Full production in two or more regions, all serving traffic | Near real time | Almost never worth the data-consistency work for a small team |
Two points from the whitepaper change how you should think about this. First, a disaster for most startups is not a region going dark. It is a dropped table, a bad migration, a compromised admin account or ransomware. Replication does not protect you there, because it faithfully replicates the deletion; only point-in-time backups do. Second, the whitepaper says that if your definition of disaster is losing a data centre, a well-architected Multi-AZ workload with backup and restore may be all you need. Pilot light and beyond are for when a whole region, or a regulator, is in scope.
Whatever strategy you choose, it only works if the infrastructure is code. Restoring data into a region where you cannot rebuild the VPC, load balancer and services in under an hour breaks your RTO. Our guide to organising Terraform state covers the layout that makes a second-region deploy a variable change rather than a project.
AWS Backup: cross-account copies and vault lock
Put your backups in a separate AWS account that production admins cannot touch, copy them to a second region, and lock the vault so nobody can delete them early. That single change covers the scenarios that actually take startups down: account compromise and human error.
The setup in an AWS Organization looks like this (if you do not have one yet, start with AWS Organizations from day one):
- From the management account, enable cross-account backup in AWS Backup settings. Both accounts must be in the same organization (AWS docs).
- In a dedicated backup account, create a vault in your recovery region with a customer managed KMS key, and a vault access policy that allows
backup:CopyIntoBackupVaultfrom your organization. The default vault cannot be a cross-account destination, and RDS copies need a customer managed key because AWS managed keys cannot be shared across accounts. - In production, add a
copy_actionto the backup plan that targets that vault. RDS and Aurora can now copy cross-region and cross-account in a single action. - Attach an SCP that denies
organizations:LeaveOrganizationto the backup account, as AWS recommends, so the copies cannot walk out with it.
resource "aws_backup_plan" "prod" {
name = "prod"
# Point-in-time recovery for RDS, up to 35 days
rule {
rule_name = "continuous"
target_vault_name = aws_backup_vault.prod.name
schedule = "cron(0 3 * * ? *)"
enable_continuous_backup = true
lifecycle {
delete_after = 35
}
}
# Daily snapshot, copied to the backup account in another region
rule {
rule_name = "daily-offsite"
target_vault_name = aws_backup_vault.prod.name
schedule = "cron(0 4 * * ? *)"
lifecycle {
delete_after = 35
}
copy_action {
destination_vault_arn = var.backup_account_vault_arn
lifecycle {
delete_after = 90
}
}
}
}
resource "aws_backup_selection" "prod" {
name = "prod-tagged"
plan_id = aws_backup_plan.prod.id
iam_role_arn = aws_iam_role.backup.arn
selection_tag {
type = "STRINGEQUALS"
key = "backup"
value = "prod"
}
}
# In the backup account, on the destination vault
resource "aws_backup_vault_lock_configuration" "offsite" {
backup_vault_name = aws_backup_vault.offsite.name
changeable_for_days = 3
min_retention_days = 7
max_retention_days = 365
}
Three details that catch teams out:
- Copies of continuous backups are snapshots. AWS Backup cannot copy RDS transaction logs, so the copy in your backup account has no point-in-time recovery (AWS docs). Your offsite RPO is your snapshot frequency, not five minutes. If a day is too much for a tier 1 database, take snapshots more often or add a cross-region read replica.
- Compliance mode is permanent. Setting
changeable_for_dayscreates a vault lock in compliance mode. The grace time is at least 3 days; after it ends, nobody, including AWS and your root user, can remove the lock or delete recovery points before they expire. Leaving that parameter out gives you governance mode, which privileged IAM users can remove. Test with governance mode, then switch. Vault lock itself has no extra charge, but you pay storage for everything it keeps. - Multi-AZ DB clusters cannot be copied. AWS Backup does not support copy operations for RDS Multi-AZ DB clusters (the three-node deployment type). Multi-AZ DB instances are fine.
If you need restores to start in another account quickly, look at logically air-gapped vaults: they are locked in compliance mode by design and can be shared with a recovery account through AWS RAM. Check the resource support list before you commit; Aurora continuous backups, for example, are not supported in them.
RDS snapshots and point-in-time recovery
RDS automated backups give you point-in-time recovery for up to 35 days, and the restore always creates a new DB instance. That second fact is the one to plan around: your application must be able to point at a new endpoint quickly.
- Backup retention can be set from 0 to 35 days (AWS docs). Zero disables automated backups. Never ship that to production.
- RDS uploads transaction logs to S3 every five minutes, so the latest restorable time is usually a few minutes behind (AWS docs). That is your realistic best-case RPO for an in-region restore.
- A restored instance loads its data blocks from S3 in the background. It is usable straight away but slower until initialisation finishes, which matters if your RTO assumes full performance.
- Restores use the default parameter group unless you specify one. Pass your custom parameter group explicitly or you will debug a missing setting during an incident.
aws rds restore-db-instance-to-point-in-time \
--source-db-instance-identifier prod-db \
--target-db-instance-identifier prod-db-restore-20261101 \
--restore-time 2026-11-01T09:14:00Z \
--db-parameter-group-name prod-postgres17 \
--db-subnet-group-name prod-db \
--vpc-security-group-ids sg-0123456789abcdef0 \
--no-publicly-accessible
Keep the database endpoint behind a name you control (a private Route 53 record or a secret your services read at start-up) so the switch is one change, not a redeploy of every service.
Restore testing: let AWS Backup prove your backups work
AWS Backup restore testing restores a chosen recovery point on a schedule, records how long it took, and deletes the restored resource afterwards. It turns "we think backups work" into evidence with a timestamp.
A plan picks recovery points (latest or random, within a window of up to 365 days); a selection says which resource types and resources to restore. Supported types include RDS, Aurora, DynamoDB, EBS, EC2, EFS, S3 and others. You can keep the restored resource for 1 to 168 hours so a script can validate it, then report the result back to AWS Backup. Restored resources carry the awsbackup-restore-test tag; if someone removes it, AWS Backup cannot clean the resource up. There is a charge per restore test on top of the restored resources, so start small.
resource "aws_backup_restore_testing_plan" "weekly" {
name = "weekly_restore_test"
schedule_expression = "cron(0 6 ? * MON *)"
start_window_hours = 4
recovery_point_selection {
algorithm = "RANDOM_WITHIN_WINDOW"
include_vaults = ["*"]
recovery_point_types = ["SNAPSHOT"]
selection_window_days = 14
}
}
resource "aws_backup_restore_testing_selection" "rds" {
name = "rds_prod"
restore_testing_plan_name = aws_backup_restore_testing_plan.weekly.name
protected_resource_type = "RDS"
iam_role_arn = aws_iam_role.restore_test.arn
validation_window_hours = 2
protected_resource_conditions {
string_equals {
key = "aws:ResourceTag/backup"
value = "prod"
}
}
}
Use a random recovery point, not always the latest; an old backup that will not restore is exactly what you need to find out about early. For validation, an EventBridge rule on the restore job can trigger a Lambda that connects to the restored database, checks that key tables have recent rows, and reports pass or fail. The AWS Backup Audit Manager control "restore time for resources meet target" then gives you a report against your RTO, which is useful evidence for a SOC 2 audit or NIS2 review.
Run a game day twice a year
Automated restore tests prove the data comes back. A game day proves the people and the runbook can bring the service back. Book two to three hours, pick one scenario, and run it against a copy of production, never production itself.
- Pick the scenario. Good ones: "a migration dropped the
orderstable 40 minutes ago", "the production account is compromised and we have lost access", "eu-central-1 is unavailable for our database". - Assign roles. One incident lead, one or two people doing the work, one person writing a timeline. Use the same roles as your incident response runbook.
- Start the clock and follow the written plan. Whenever someone has to improvise, write down what was missing.
- Measure the real RPO and RTO. RPO: the time of the last data you got back versus the time of the "incident". RTO: from declaring the incident to a passing smoke test.
- Fix the plan within a week. Each gap becomes a ticket with an owner. If the measured RTO missed the target, either fix the process or change the target with management's agreement.
The first game day almost always finds something boring: an expired credential, a KMS key policy that blocks the restore role, a security group nobody remembered. That is the point.
A one-page DR plan template
The plan has to fit on one page and live somewhere you can reach when AWS SSO is the thing that is broken. Keep a copy outside your AWS accounts.
DISASTER RECOVERY PLAN — [Company] Owner: [name] Reviewed: [date]
1. SCOPE AND TARGETS
System Tier RPO RTO Strategy Recovery region
prod Postgres 1 15 min 1 h PITR + pilot light eu-west-1
API (ECS) 2 n/a 4 h redeploy from IaC eu-west-1
S3 uploads 2 1 h 4 h replication + versioning
Analytics 3 24 h 2 days daily backup
2. WHO DECIDES
Declares disaster: [CTO], backup: [lead engineer]
Customer comms: [name] Status page: [URL]
3. ACCESS IF NORMAL LOGIN FAILS
Break-glass account: [where the credentials are kept]
Backup account ID: [id] Recovery vault: [ARN]
4. RECOVERY STEPS (link to runbook for each)
a. Data deleted or corrupted -> PITR restore to new instance, switch endpoint
b. Account compromised -> restore from backup account into clean account
c. Region unavailable -> promote replica / restore copies, deploy IaC
5. VERIFY
Smoke tests: [list] Data checks: [queries] Who signs off: [name]
6. TESTING
Automated restore test: weekly (AWS Backup) Last game day: [date, result]
Next game day: [date]
Where to start this week
If you do nothing else: turn on Multi-AZ and a backup retention period of at least 7 days for production databases, copy backups to a separate account with a vault lock, schedule one restore test, and write the page above. That takes a few days and covers the disasters startups actually have.
If you want a second pair of eyes on it, our cloud audit checks backups, restore paths and blast radius alongside security and cost, and our managed DevOps service runs the restore tests and game days for you, so the plan stays true after the person who wrote it moves on.
To see what your recovery targets mean in practice, the free uptime and SLA calculator turns an availability target into minutes of allowed downtime and error budget.
Frequently asked questions
What are the four AWS disaster recovery strategies?
Backup and restore, pilot light, warm standby and multi-site active/active. AWS orders them from cheapest and slowest (recovery in hours) to most expensive and fastest (near real time). Most startups should use backup and restore with cross-account copies, and pilot light only for the few systems where a region outage must be survivable.
What is the difference between RPO and RTO?
RPO (recovery point objective) is the maximum amount of data, measured in time, you can afford to lose. RTO (recovery time objective) is the maximum time a system can be unavailable. Set both per system, then test them; an RTO nobody has measured during a restore is only a guess.
Does AWS Backup copy RDS point-in-time recovery to another account?
No. AWS Backup cannot copy RDS transaction logs, so cross-account and cross-region copies of continuous backups become snapshots without point-in-time recovery. Your offsite recovery point is therefore as recent as your last copied snapshot. Take snapshots more often or add a cross-region read replica if that is not enough.
Can anyone delete backups protected by AWS Backup Vault Lock?
In compliance mode, once the grace time of at least 3 days has passed, nobody can remove the lock or delete recovery points before their retention ends, including the root user and AWS. In governance mode, users with the right IAM permissions can remove the lock. Test with governance mode first.