AWS disaster recovery for startups: RPO, RTO and a plan you can test

· 10 min read · aws · reliability

Most startups do not need a second live region. They need backups an attacker cannot delete, a restore they have actually timed, and a written plan. This is how we set that up on AWS.

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.

TierTypical systemsStarting RPO / RTOUsual strategy
Tier 1Core transactional database, auth, payments flowMinutes / under an hourMulti-AZ plus point-in-time recovery; pilot light in a second region if a region outage is in scope
Tier 2Main application, APIs, background workersHours / a few hoursBackup and restore, infrastructure as code ready to redeploy
Tier 3Analytics, internal tools, stagingA day / a day or moreDaily 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.

StrategyWhat runs in the recovery regionRPO / RTO (AWS whitepaper)When it fits a startup
Backup and restoreNothing; backups are copied there and infrastructure is redeployed from codeHoursThe default for almost everything
Pilot lightData is replicated continuously (for example an RDS cross-region read replica); app servers are defined but not deployedTens of minutesTier 1 databases when a region outage must be survivable
Warm standbyA scaled-down but working copy of production that can take traffic immediatelyMinutesRare at seed or Series A; usually driven by a customer contract
Multi-site active/activeFull production in two or more regions, all serving trafficNear real timeAlmost 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):

  1. From the management account, enable cross-account backup in AWS Backup settings. Both accounts must be in the same organization (AWS docs).
  2. 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:CopyIntoBackupVault from 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.
  3. In production, add a copy_action to the backup plan that targets that vault. RDS and Aurora can now copy cross-region and cross-account in a single action.
  4. Attach an SCP that denies organizations:LeaveOrganization to 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:

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.

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.

  1. Pick the scenario. Good ones: "a migration dropped the orders table 40 minutes ago", "the production account is compromised and we have lost access", "eu-central-1 is unavailable for our database".
  2. 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.
  3. Start the clock and follow the written plan. Whenever someone has to improvise, write down what was missing.
  4. 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.
  5. 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.

Tell us what you need