How to Set a Recovery Time Objective Your Host Can Actually Meet
A recovery time objective your host can actually meet is one you derive from what the infrastructure does under failure, not from what sounds acceptable in a meeting. Pick the number by measuring the slowest real step in your restore path and then adding headroom for the steps you cannot control, and treat anything faster than that as an aspiration to be funded, not a commitment to be written down. The same logic applies to the recovery point objective: your backup cadence sets the floor, and no amount of documentation moves it.
Most recovery time objective hosting discussions go wrong because the plan is written backwards. Someone writes "four hours" because four hours feels defensible, then hands it to a provider whose snapshot schedule, DNS TTLs and database restore process have never been timed end to end. The number survives in the document and dies in the incident.
Work out what the recovery time objective hosting setup can physically deliver
Start by listing the steps between "we decide to fail over" and "traffic is being served from the recovery environment", in order, and time each one. The steps that catch people out are rarely the ones they expect.
DNS is usually the largest fixed cost. If your records carry a TTL of 3600 seconds, you have already spent an hour before any client even learns the new address, and some resolvers and client caches will hold on longer. You can check what the world currently sees with dig:
$ dig +noall +answer www.example.com A
www.example.com. 3600 IN A 203.0.113.10
That 3600 is a hard floor on your RTO for any recovery that depends on changing an address. Lowering it ahead of time is a trade: short TTLs make failover faster and increase query volume. A common compromise is to keep the TTL moderate in normal operation and drop it when you are about to do maintenance, but remember that the old long TTL is still cached in resolvers that have not re-queried yet. There is no way to revoke a cached record early.
Next, time the data restore. A database dump that takes twenty minutes to load on your laptop may take far longer on the target instance, especially if it is a smaller class than production, and longer still if the backup is compressed and you are decompressing on the same box. Measure it on hardware comparable to what you would actually recover onto. If your only tested restore was onto a generously sized staging machine, your RTO is fiction.
Then add the human steps. Someone has to notice the alert, confirm it is not a false positive, find the runbook, get credentials, and make the call to fail over. If that decision needs a second person's approval, add their wake-up time. An RTO that assumes instant, correct human action at any hour is not an RTO, it is a hope.
Match the recovery point objective to your backup cadence
The RPO is bounded by how often you take a recoverable copy, and by whether that copy is consistent. A nightly logical dump gives you an RPO of up to a day, and the worst case is always the full interval, not the average. If you need a tighter RPO, the cadence has to change, which usually means continuous archiving of the write-ahead log or its equivalent rather than more frequent full dumps.
For PostgreSQL, point-in-time recovery depends on archive_mode and archive_command in postgresql.conf, plus retained base backups. The RPO is roughly the interval between archived segments, so if you are shipping a segment every minute, you are exposed to about a minute of lost writes, plus whatever is sitting in an unarchived segment at the moment of failure.
archive_mode = on
archive_command = 'test ! -f /mnt/wal-archive/%f && cp %p /mnt/wal-archive/%f'
archive_timeout = 60s
The archive_timeout line forces a segment switch even when the database is quiet, which caps your exposure but also fills the archive with partly empty segments. Verify that archives are actually arriving rather than trusting the config. A quick check is to ask the server how much WAL it has generated and compare that against what the archive contains:
postgres=# SELECT pg_current_wal_lsn(), pg_walfile_name(pg_current_wal_lsn());
pg_current_wal_lsn | pg_walfile_name
--------------------+-------------------------
0/3A000120 | 00000001000000000000003A
If the file named there is not present in your archive within a couple of minutes, your RPO is not what the config claims. Silent archive failures are one of the most common reasons a recovery point objective turns out to be unachievable in practice.
Test the numbers, then write them down
An RTO and RPO only mean something once you have run a restore and measured it. Schedule a real exercise against a separate environment, restore from the same backups you would use in anger, and record the wall clock time for each step. Include the boring parts: fetching credentials, provisioning the replacement instance, updating the application configuration, and waiting for DNS.
When you have the measurements, set the published numbers above the worst observed time, not at the average. If your best measured restore is ninety minutes and your worst is three hours, publish something the worst case respects. Then state the assumptions alongside the number: the size of the dataset at test time, the instance class used, and the TTL in force. Numbers without their assumptions get quoted out of context and quietly become promises.
Finally, check what your provider actually commits to in writing, because your RTO cannot be better than the parts you do not control. Look for the documented recovery behaviour for the specific service you use, not the marketing page, and confirm that backups are restorable by you rather than only by support staff during business hours. If a restore requires opening a ticket and waiting for a queue, that queue time belongs in your RTO whether you like it or not.
What to do next: pick your most important service, time a full restore from backup onto comparable hardware this week, and write down every step that surprised you. Compare that elapsed time against the RTO in your current plan, adjust the number to match reality, and put the next test in the calendar with a named owner. A tested, slightly unambitious objective beats an impressive one that has never been run.
