Recovery Point Objective (RPO) and Recovery Time Objective (RTO) sit side by side on almost every compliance questionnaire, yet they measure opposite directions from the moment an outage begins. RPO looks backward in time to your most recent durable backup or replicated transaction: if the primary database disappears right now, can the business afford to lose five minutes of committed writes, or twenty-four hours? RTO looks forward from initial disruption until verified customer traffic is flowing normally again, whether that ceiling is thirty minutes or four hours.
Writing both numbers into a policy document takes very little effort. Meeting them during a live failure is another matter. It is not unheard of for a company to promise a 30-minute RTO in customer contracts while engineering runs nightly logical backups that need three hours just to rebuild indexes. Maybe the question isn't what RTO looks reassuring in a policy doc, but rather what your current storage, replication, and DNS setup can physically finish when everything starts cold? You can test your own stage timings in our RTO & RPO Drill Gap Calculator and compare contractual uptime allowances in our SLA Uptime Calculator.
Where Recovery Time Actually Goes
Teams frequently estimate RTO by timing a database restore command in isolation. Customers sit through the entire outage clock, not just the storage step.
Before anyone runs a single recovery command, monitoring has to detect the failure: probe intervals, evaluation windows, and paging delivery all burn minutes before an engineer even opens a laptop. Responder triage comes next, confirming the primary will not recover faster in place and getting Incident Commander approval to fail over, particularly when promoting an asynchronous standby means accepting non-zero data loss. Only then does storage restore or standby promotion begin, and cloud block storage hides an easy trap here: AWS EBS volumes restored from S3-backed snapshots hydrate blocks lazily on first disk read, throttling initial database I/O severely unless Fast Snapshot Restore is enabled or a warm streaming replica is already running. Once the database accepts connections, you still have to boot or repoint application containers, run smoke checks before opening public traffic, and shift load-balancer targets or wait out authoritative DNS TTL caches.
See how fast those clocks add up on a SaaS billing PostgreSQL database carrying a 30-minute RTO target and a 5-minute RPO target. Suppose monitoring takes 6m to page, triage and authorization take 11m, restoring a cold snapshot and replaying WAL segments takes 38m, smoke verification takes 9m, and a 600-second DNS TTL adds another 10m. That totals 74 minutes end to end—44 minutes past target—along with 8.5 minutes of unshipped archive lag. Seeing each clock separately makes the architectural fix plain: hitting a 30-minute ceiling takes both a warm streaming standby and a 60-second DNS TTL.
Sizing PostgreSQL Architecture to Your Targets
Stateless web containers spin up in a couple of minutes. Stateful databases set your real recovery floor. The comparison below maps four standard PostgreSQL architectures across an illustrative ~1 TB production database:
| Database Architecture | Typical RPO | Typical Total RTO | Illustrative Cost Multiplier | Primary Operational Trade-Off |
|---|---|---|---|---|
Nightly pg_dump to object storage |
12 to 24 hours | 4 to 10+ hours | ~1.05x base | Logical restore and index rebuilds crawl on multi-hundred-GB tables |
| Physical base backup + continuous WAL PITR | 1 to 5 minutes | 45 to 180 minutes | ~1.15x - 1.3x base | Must hydrate base volume from S3 and replay WAL segments sequentially |
| Asynchronous cross-region streaming replica | Seconds (normal); minutes under heavy write bursts | 10 to 25 minutes | ~1.8x - 2.2x base | Unshipped WAL bytes on a dead primary are lost on forced promotion |
| Synchronous Multi-AZ standby + cross-region PITR | 0 bytes (single-AZ loss); 1-5m (full region loss) | 2 to 5m (AZ); 30-90m (region) | ~2.2x - 3.5x base | Adds cross-AZ round-trip latency to every COMMIT; requires disciplined connection pooling |
Why Streaming Replication Does Not Replace Point-in-Time Recovery
High-availability replicas protect well against dead hardware and lost Availability Zones. Human mistakes and application bugs behave differently. If a deployment script accidentally runs an unscoped DELETE FROM invoices; on the primary node, both synchronous and asynchronous replicas apply that exact deletion within milliseconds. Recovering from logical corruption still requires continuous WAL archiving into an immutable backup vault, so an engineer can restore a physical base backup into an isolated subnet and stop replay one transaction before the bad query ran.
Checking Real PostgreSQL Replication Lag in SQL
Cloud console health badges still report "Available" when an asynchronous replica falls fifteen minutes behind during a heavy batch import. Query the standby directly, comparing received and replayed LSNs first so an idle cluster with no recent writes does not trigger false lag alarms:
-- Run on the PostgreSQL standby to check actual replay delay without idle-cluster false alarms
SELECT
CASE
WHEN pg_last_wal_receive_lsn() = pg_last_wal_replay_lsn() THEN INTERVAL '0 seconds'
ELSE now() - pg_last_xact_replay_timestamp()
END AS replay_lag,
pg_last_wal_receive_lsn() AS received_lsn,
pg_last_wal_replay_lsn() AS replayed_lsn;
You can also check unshipped and unreplayed byte lag from the primary node through pg_stat_replication:
SELECT application_name, state, sync_state,
pg_wal_lsn_diff(pg_current_wal_lsn(), sent_lsn) AS unsent_bytes,
pg_wal_lsn_diff(pg_current_wal_lsn(), replay_lsn) AS unreplayed_bytes,
replay_lag
FROM pg_stat_replication;
Once your targets match what your database architecture can deliver, turn them into working procedures with our IT disaster recovery plan template and DR runbook template, or talk with briskData about disaster recovery engineering.