A backup you have not restored is not a backup. It is a file, and the belief that it is a backup is the actual risk, because that belief is what stops you from building the thing that would have saved you.
This is not a rhetorical point. The failure modes are specific and common. The archive command was failing silently for weeks and the monitoring only watched the backup job, not the WAL stream. The base backup completed but excluded a tablespace nobody remembered adding. The restore works but takes long enough that the business has already made decisions assuming the data is gone. The encryption key is in the same account that got compromised. Every one of these is invisible until you attempt a restore, and every one of them is found in an afternoon by a team that attempts restores on a schedule.
So the useful framing for this category is not which tool takes the best backup. Nearly all of them take a correct backup. It is which tool makes restoring routine, verifiable and fast enough, and which one tells you loudly when the chain is broken rather than when you need it.
The second framing is that recovery point and recovery time objectives are measurements you take, not promises a vendor makes. Your RPO is whatever the gap is between your last durable WAL segment and now, which is a number you can read off your own archive. Your RTO is how long your last restore drill took, plus the time it takes a human to decide to start one. Neither of those appears in a datasheet.
Key takeaways
- Point-in-time recovery is a base backup plus a continuous stream of write-ahead log segments. If either half is broken, you have the other half and no recovery.
- RPO is measurable from your own WAL archive lag. RTO is measurable from a restore drill. Treat any number you did not measure yourself as marketing.
- Restore speed, not backup speed, is the property to select on. Parallel restore, delta restore and the ability to start recovery before the full copy lands are what separate the tools.
- Cross-region durability costs storage, egress and operational complexity in different proportions depending on whether you replicate the backup or the database. Price all three.
How point-in-time recovery actually works
Understanding the mechanism makes every tool decision below obvious, and it takes two paragraphs.
Postgres writes every change to a write-ahead log before it touches a data page. The WAL is a sequence of fixed-size segments, and replaying them against a consistent starting point reconstructs the database exactly. So a point-in-time recovery has two ingredients: a base backup, which is a physical copy of the data directory taken while the database is running, and every WAL segment produced from the moment that base backup started up to the moment you want to recover to.
Recovery is then mechanical. You restore the base backup, point the server at the WAL archive, and give it a recovery target: a timestamp, a transaction ID, a named restore point, or simply the end of the archive. The server replays WAL until it reaches the target, then stops and opens. The granularity of “point in time” is exactly as fine as your WAL is complete.
Two consequences follow, and they are the source of most real incidents.
The WAL archive is the fragile half. A base backup is a discrete job that either succeeds or fails visibly. WAL archiving is continuous, and when archive_command starts failing, Postgres keeps the unarchived segments on disk rather than deleting them. Your recovery window silently stops advancing while your disk silently fills. The first symptom is often a full data volume, not a backup alert. Monitor archive failure count and the lag between the current WAL position and the last archived segment as first-class metrics, not as a checkbox on a backup job.
Retention policy and recovery window are the same decision. If you keep base backups for a week but WAL for three days, your actual recoverable window is three days no matter what your backup retention says. Tools that manage both together, expiring WAL only when no retained backup still needs it, prevent a category of mistake that manual scripts make constantly.
Logical replication is a different mechanism and worth separating in your head. Physical WAL shipping copies bytes and gives you an identical replica. Logical replication decodes WAL into row-level changes and gives you a subscriber that can differ in version and schema. Logical replication is excellent for migrations and for change data capture, and it is not a backup, because it faithfully replicates the DELETE that a bad migration issued.
Provider-native point-in-time recovery: a feature, not a product
Every managed Postgres offering includes some form of automated backup with point-in-time recovery. It is a feature of your host, not something you buy separately, and for a large number of teams it is the correct and complete answer. It is worth understanding precisely what you get, because it differs more than the marketing suggests.
What it gives you
- Base backups and WAL archiving configured, monitored and retained by someone whose job it is, with no
archive_commandof yours to fail silently. - Restore as an operation rather than a procedure. Choose a timestamp, get a new instance. The steps you would otherwise script are the provider’s problem.
- Storage-layer snapshots on some platforms, where the backup is taken at the block device or at a disaggregated storage service, which changes restore characteristics substantially compared with a file copy.
- Integration with the provider’s own identity and encryption, so key management is not a separate project.
What it does not do
- Restore into a different provider. Almost all native backups restore into the same platform, which means your disaster recovery plan has a single vendor as a dependency and your exit strategy needs a separate logical dump anyway.
- Give you a restore you can test cheaply. Restoring to verify usually means provisioning a new instance and paying for it, which is why so few teams do it on a schedule.
- Cover application-level mistakes with fine granularity. Recovering one accidentally deleted tenant means restoring the whole database to a point in time and then copying rows out, which is slow and manual on any platform.
- Guarantee a recovery window you control. Retention is a setting within the provider’s supported range, and long retention for compliance usually needs a separate export.
The pragmatic position: use native PITR as your primary recovery mechanism, and add one independent backup written to storage in a different account or provider as your insurance against account compromise and against the platform itself. Comparing what each host offers here is part of the managed Postgres decision, and it is more decision-relevant than most feature grids admit.
RPO and RTO are things you measure
Both of these get quoted as targets in planning documents and neither means anything until you have measured your actual numbers.
Your real RPO is the age of the newest durable copy of your data at the moment of failure. With continuous WAL archiving, that is the time since the last segment was successfully written to remote storage. Two things inflate it beyond what you expect. A low-traffic database may not fill a WAL segment for a long time, so unless archive_timeout forces a switch, your newest archived segment can be much older than your newest committed transaction. And a slow or failing archive destination adds its backlog directly to your exposure. Both are measurable right now, on your running system, without a vendor.
Your real RTO is the wall-clock time from the decision to restore to the application serving traffic again. It decomposes into: time to detect and decide, time to provision the target, time to fetch the base backup, time to replay WAL, time to run post-recovery checks, and time to repoint the application. Most teams have only ever estimated the middle part and ignored the ends. The decision time is often the largest term, because nobody wants to be the person who declared a disaster.
WAL replay time deserves special attention because it grows with the distance between your base backup and your recovery target. Recovering to a point shortly after a nightly backup is fast. Recovering to a point shortly before the next one replays a full day of changes, single-threaded in the general case. This is the argument for more frequent incremental or differential backups, and it is the number people are most surprised by during their first drill.
Needs first-hand data: Run a full restore drill against a copy of production. Record six timings separately: decision to start, provisioning the target host, fetching the base backup, WAL replay to a target timestamp midway between two backups, post-restore validation queries, and application cutover. Publish the total as your RTO and the WAL replay figure as the number that will change if you adjust backup frequency. Repeat quarterly, because it drifts as the database grows.
Restore testing has to be automated or it will not happen
Everyone agrees restores should be tested. Almost nobody tests them, because a manual drill costs a day and competes with shipping. The only version of this that survives contact with a real roadmap is one that runs without a human.
What a working restore-test pipeline does:
Restores to a throwaway target on a schedule. Weekly is a reasonable default. The target is ephemeral, created and destroyed by the job, so the ongoing cost is compute time rather than a permanently running standby.
Restores to a random point in time, not to the latest backup. Restoring the most recent base backup tests the base backup. Restoring to a timestamp partway through a WAL series tests the archive, the retention interaction and the replay path, which is where the real failures live.
Validates content, not just startup. A server that starts is not a server with your data. Run a small set of assertions: row counts on your largest tables within an expected band, the newest row in an append-only table being close to the recovery target, a checksum over a stable reference table, and a join across two tables that would fail if a tablespace were missing.
Reports the elapsed time as a metric. Restore duration trending upward is a capacity signal that arrives long before it becomes an incident. Chart it next to database size.
Fails loudly. A restore test that fails quietly is worse than none, because it manufactures the confidence the practice was supposed to earn. Route it to the same place as production alerts, and treat a failure as a real incident with a real postmortem.
Several tools below can verify backups without a full restore by checking checksums and manifest integrity. That is worth doing continuously, and it is not a substitute for a restore, because it validates the bytes rather than the procedure, and the procedure is what fails.
Needs first-hand data: Instrument the restore-test job to emit three numbers on every run: total wall-clock duration, bytes fetched from backup storage, and WAL segments replayed. Keep a year of history. The trend in duration against database size tells you when your current backup frequency stops meeting your RTO, which is a decision you want to make on a graph rather than during an outage.
Cross-region durability and what it actually costs
Keeping backups in one region protects you from a host failure and a bad migration. It does not protect you from losing the region or losing access to the account that owns the bucket.
There are three shapes of cross-region protection and they cost differently.
Replicate the backup storage. Cheapest and simplest. The backup tool writes to object storage, and the bucket replicates to another region. You pay storage twice and egress once per object, and your cross-region RTO includes fetching everything back. This is usually the right default.
Ship WAL to a second destination. Some tools support multiple archive destinations, so the second region receives segments independently rather than through bucket replication. Better RPO in the second region and more moving parts to monitor, because now there are two archive chains that can fail separately, and you need alerting on both.
Run a warm standby in the second region. Lowest RTO by a wide margin, highest cost, because you are paying for a second running database continuously plus the replication traffic. Justified when the recovery time genuinely cannot be measured in hours.
Two details that catch people out regardless of shape. Cross-account matters more than cross-region for the ransomware and credential-compromise scenarios, because an attacker with your credentials can delete replicated buckets as easily as the original; object lock or immutable retention is the control that helps, and it needs to be configured before you need it. And encryption keys must be available in the recovery region, held somewhere that does not depend on the thing you are recovering from. A backup you cannot decrypt is a very expensive random number.
pgBackRest

pgBackRest is the most capable dedicated Postgres backup tool available, and it is what I would reach for on a self-managed Postgres of any size. It handles full, differential and incremental backups, parallel compression and transfer, page-level checksum verification, multiple repositories including object storage, encryption, and retention that keeps WAL and base backups consistent with each other. Its delta restore only fetches blocks that differ from what is already on the target, which changes restore economics on a large database substantially.
Pros
- Parallel backup and restore across multiple processes, which is the main lever on both backup window and recovery time for a large cluster
- Delta restore reuses an existing data directory and transfers only changed blocks, turning a repeated restore drill from expensive into routine
- Multiple repositories with independent retention, so a local repository for fast restores and a remote one for durability is a supported configuration rather than a hack
- Backup verification, page checksum validation and a consistent retention model that expires WAL only when no retained backup still needs it
Cons
- Configuration has real surface area, and getting repositories, retention, archiving and stanza definitions right takes a careful read rather than a copy-paste
- Postgres only, so a mixed estate needs a second tool and a second runbook
- You own the scheduling, the monitoring and the restore automation; the tool does the hard part correctly and hands the operational wrapper to you
Best for: Teams running self-managed Postgres where database size makes restore time a real constraint and a dedicated tool is worth learning properly.
Pricing: Open source with no licence cost. You pay for backup storage, the network transfer, and the engineering time to configure and monitor it correctly.
Barman
Barman is the other mature dedicated Postgres backup manager, built around the idea of a backup server that manages several Postgres instances centrally. It supports both rsync-based and streaming backup methods, WAL streaming via replication slots as an alternative to archive_command, and it exposes a clear command surface for listing, checking and recovering backups. Its barman check command validating the whole chain for an instance is a genuinely good operational primitive.
Pros
- Centralised model suits an estate of several Postgres instances managed by one team, with one inventory and one place to check status
- WAL streaming through a replication slot reduces the window compared with segment-file archiving, and removes the silent
archive_commandfailure mode - Built-in consistency checking validates the whole backup and WAL chain per instance rather than only the last job
- Incremental backup support via rsync hard links keeps repeated full backups cheap on storage where deduplication is not otherwise available
Cons
- The backup server is itself a component to run, secure and keep available, and a centralised design makes it a shared failure point if you do not treat it as production
- Object storage support and cloud-native workflows arrived later than in the tools designed around them, so the configuration feels more bolted on
- Parallelism and restore throughput are generally behind pgBackRest on very large databases
Best for: Teams administering multiple self-managed Postgres instances who want one central backup server with a clear inventory and check command.
Pricing: Open source with no licence cost, with commercial support available; the real cost is running and securing the backup server plus its storage.
WAL-G
WAL-G is an archival and restoration tool designed around object storage from the start, and it is the pragmatic choice when your backup destination is a bucket and your priority is simple operation rather than maximum feature coverage. It handles base backups, WAL archiving, delta backups and encryption, with parallel upload and download, and it supports several database engines beyond Postgres. Its footprint is a single binary invoked from archive_command and from a scheduled job.
Pros
- Object-storage native across the major cloud providers, so there is no intermediate backup server to run or secure
- A single binary with a small configuration surface, which makes it easy to put in a container image and run in a Kubernetes-managed database setup
- Delta backups and parallel transfer keep both backup windows and restore times reasonable without much tuning
- Supports several engines beyond Postgres, which reduces the tool count in a mixed estate that is nevertheless cloud-storage based
Cons
- Less operational tooling around verification, inventory and retention reporting than the dedicated Postgres managers, so you build more of the wrapper yourself
- Documentation and behaviour vary somewhat between the engines it supports, and the Postgres path is better trodden than the others
- Silent misconfiguration is easy because the tool is invoked per WAL segment; without your own monitoring, a broken archive looks like nothing at all
Best for: Cloud-native teams backing up Postgres directly to object storage who want a single binary rather than a backup server.
Pricing: Open source with no licence cost. You pay for object storage, request volume, cross-region transfer, and the monitoring you write around it.
AWS Backup
AWS Backup is a policy and orchestration layer rather than a backup engine. It centralises backup plans, retention, cross-region and cross-account copies, and compliance reporting across many AWS services, delegating the actual snapshot mechanics to each service. For a Postgres estate running on managed AWS databases, it turns per-resource backup settings into one governed policy with an audit trail.
Pros
- One policy model across databases, file systems and volumes, which is what an auditor actually wants to see rather than a per-resource screenshot
- Cross-account and cross-region copy with vault lock style immutability addresses the credential-compromise scenario that same-account backups do not
- Compliance reporting and centralised monitoring of backup job status removes the most common gap, which is nobody noticing a job stopped running
- Deep integration with existing identity and key management, so encryption and access control are not a separate build
Cons
- It orchestrates snapshots rather than managing WAL, so the granularity and restore behaviour are whatever the underlying service provides, not something you can tune
- Restores land back into the same cloud, so it does not address platform-level exit or a provider-wide failure
- Self-managed Postgres on a virtual machine gets volume snapshots rather than database-aware backups, which is a weaker guarantee than a tool that understands checkpoints and WAL
Best for: Teams standardised on AWS managed databases who need centralised retention policy, cross-account copies and compliance evidence more than they need restore tuning.
Pricing: Metered on backup storage consumed, with separate charges for cross-region and cross-account copy and for restore operations; the meter is storage and data movement rather than a licence.
Percona XtraBackup
Percona XtraBackup is the standard open-source hot backup tool for MySQL and its forks, performing physical backups of a running server without blocking writes for the duration. It belongs in this comparison because most Postgres estates are not the only database in the building, and the tool you use for MySQL should be as deliberate a choice as the one you use for Postgres. It supports incremental backups against a previous backup’s log sequence number, compression, encryption and streaming to a remote destination.
Pros
- Physical hot backup of a running MySQL server without locking out writes for the whole backup, which is the baseline requirement for a busy production database
- Incremental backups keyed to log sequence numbers keep the daily cost proportional to change rather than to database size
- Streaming output composes well with object storage and with pipes, so it fits existing shell-based operational tooling without a wrapper product
- Long track record and wide familiarity, which matters when the person running the restore at three in the morning is not the person who set it up
Cons
- MySQL family only, so it solves a different half of a mixed estate rather than unifying it
- Version compatibility between the tool and the server is strict, and a mismatch after a server upgrade is a common and avoidable outage in waiting
- The prepare step before a restore takes time proportional to the log to apply, which is easy to forget when estimating recovery time
Best for: Teams running self-managed MySQL or MariaDB alongside Postgres who need a hot physical backup with incremental support.
Pricing: Open source with no licence cost, with commercial support sold separately; the real cost is storage, transfer and keeping tool and server versions aligned.
Veeam
Veeam comes at this from infrastructure backup rather than from the database, covering virtual machines, physical servers, cloud workloads and increasingly databases and applications under one platform with one retention policy. In an organisation where backup is a centralised function with its own team and its own audit obligations, that consolidation is the point. For a database specifically, it is generally a coarser instrument than a database-aware tool.
Pros
- One platform and one policy across virtual machines, file systems, cloud workloads and databases, which is what a centralised backup function needs to report on
- Immutable and air-gapped repository options address ransomware scenarios explicitly rather than incidentally
- Instant recovery style features that run a workload directly from backup storage can dramatically shorten the time to a usable system, even before a full restore completes
- Mature reporting, role separation and audit trails built for organisations where backup is a governed function rather than a team habit
Cons
- Database-aware granularity is behind dedicated tools; point-in-time recovery to an arbitrary transaction is not the native unit of work the way it is with WAL-based tooling
- Enterprise licensing and agent deployment are heavy for a small team running a handful of database servers
- Consolidating databases into a general infrastructure backup regime tends to mean database restore procedures are owned by people who do not run the database daily
Best for: Enterprises with a centralised backup function covering mixed infrastructure where the database is one workload among many under a single retention and compliance policy.
Pricing: Per-workload or per-instance subscription licensing across the protected estate, with separate costs for repository storage and cloud-tier capacity.
How to choose
Answer four questions in order and the shortlist collapses quickly.
Are you managing Postgres yourself? If not, your primary mechanism is your provider’s PITR, and this decision is about what independent second copy you add, not about replacing it. Go straight to an object-storage tool writing to a different account and stop.
How long does WAL replay take at your size? Measure it. If replaying a day of WAL is comfortably inside your tolerance, nightly base backups plus continuous archiving is enough. If it is not, you need incremental or differential backups more frequently, and that requirement selects for the tools built around it.
Does a repeated restore need to be cheap? If you intend to run weekly automated restore drills, and you should, delta restore that transfers only changed blocks is the feature that makes the ongoing cost tolerable on a large database.
Who owns backup in your organisation? If it is the team that runs the database, pick the database-aware tool and accept the configuration work. If it is a central function with audit obligations across mixed infrastructure, a platform that reports on everything in one place is worth more than the granularity you give up, and fighting that is not a battle worth having.
Then, whatever you choose: monitor archive lag, automate a restore to a random point in time, validate content rather than startup, keep one copy in a different account with immutability on, and make sure the encryption key lives somewhere the disaster does not.
| Tool | Scope | Backup type | Restore optimisation | Storage target | Operated by |
|---|---|---|---|---|---|
| pgBackRest | Postgres | Full, differential, incremental | Parallel and delta restore | Local and object storage | You |
| Barman | Postgres | Full plus WAL streaming | Incremental via hard links | Backup server, object storage | You |
| WAL-G | Postgres and others | Full and delta | Parallel fetch | Object storage | You |
| AWS Backup | AWS services | Service-native snapshots | Provider-defined | AWS vaults | Provider policy |
| Percona XtraBackup | MySQL family | Full and incremental | Prepare then copy | Local, streamed, object storage | You |
| Veeam | Mixed infrastructure | Image and application-aware | Instant recovery from backup | Repositories and cloud tiers | Central backup team |
| Provider-native PITR (feature, not a product) | Your managed database | Base plus WAL, managed | Provider-defined | Provider-managed | Provider |
Frequently asked questions
How often should I run a restore test?
Often enough that the procedure is boring. Weekly automated restores to an ephemeral target is a reasonable target for a production database, with a human-run full drill quarterly to test the parts automation skips, which are mostly the decision-making and the application cutover. The frequency matters less than the automation; a manual quarterly drill that keeps slipping is worth less than a weekly job nobody has to remember.
Is streaming replication a backup?
No. A replica applies every change faithfully, including the accidental DELETE and the bad migration, usually within seconds. It protects against hardware and host failure, which is valuable, and it protects against nothing you did to yourself. Delayed replicas narrow this gap by holding replay back for a fixed interval, which buys you a window to notice, and they are still not a substitute for archived backups.
What is a realistic RPO with WAL archiving?
Whatever your archive lag is, which you can measure today. The floor is set by how quickly segments reach durable remote storage, and for a low-traffic database it is set by archive_timeout forcing a segment switch rather than by traffic filling one. Streaming WAL to the archive rather than shipping completed segments reduces it further. Measure it on your own system and stop quoting targets you have not verified; your monitoring setup should chart archive lag beside query latency.
How do I restore just one table or one customer?
Physical PITR restores the whole cluster, so the usual procedure is restore to a separate instance at the right timestamp and then copy the rows you need across with a logical dump. That is slow and manual, which is why teams with frequent single-tenant recovery requirements build periodic logical exports per tenant on top of physical backups. If that is a common request for you, design for it explicitly; the multi-tenant architecture guide covers how the tenancy model changes the cost of this enormously.
Related reading
- Best managed Postgres providers — what each host gives you natively and where its retention stops.
- Best database monitoring tools — archive lag and long transactions are monitoring problems before they are backup problems.
- Best tools for multi-tenant database architecture — why per-tenant restore is easy in one architecture and painful in another.
- Best change data capture tools — logical replication as a migration and streaming mechanism, not as a backup.
- Best postmortem and incident retrospective tools — a failed restore drill deserves the same treatment as an outage.