Physical and incremental backups in Databasus now run on the native PostgreSQL 17 backup engine. They used to rely on a custom implementation, the same general approach most backup tools take. That approach is solid and it is everywhere in the industry. We chose to go further and trade a little version coverage for the most efficient backups available, so native physical backups now target PostgreSQL 17 and higher. Logical backups are unchanged, so most setups carry on exactly as before.
Why we moved off the standard approach
The first version of physical backups tracked changed data on its own and assembled backups with its own logic. This is the normal way to do it. Most backup tools work like this, because for a long time the database did not expose a better option. It is a reasonable approach and it serves a lot of people well.
But it does leave efficiency on the table, and it carries some long-term costs.
- It repeats work the database can now do internally, which leaves performance unused.
- It lives outside the PostgreSQL test suite, so correctness rests on each tool's own testing.
- It is more code to maintain, sitting next to the database instead of inside it.
- It follows new PostgreSQL versions by hand, so it always trails what the database can do.
None of this makes the standard approach bad. It was the right call back when there was no native option. PostgreSQL 17 changed that, so we took the chance to do it the most efficient way and accept the version trade-off that comes with it.
What native PostgreSQL 17 backups actually are
PostgreSQL 17 ships its own block-level incremental backup support. Databasus now builds directly on it instead of reinventing it. The flow is simple to reason about and it maps cleanly onto how the database already works. Here is what each stage does in plain terms.
| Backup stage | What it does |
|---|---|
| Full base backup | Copies the whole database cluster at the file level |
| Incremental backup | Saves only the data blocks that changed since the last backup |
| Continuous WAL | Records every change so you can recover to any second |
| Restore | Rebuilds the data directory using PostgreSQL's own native handling |
How incremental and point-in-time recovery work
You start from a full base backup. After that, each incremental backup stores only the blocks that changed, so the backups stay small and fast even on big databases. PostgreSQL keeps a continuous record of every change as the database runs. To recover, you pick a moment in time and the database replays its change log up to that exact second. The result is the database as it was right before whatever went wrong.
The whole chain is something PostgreSQL understands natively, so nothing has to be translated or reassembled by Databasus. That is the point of the change.
Why native wins: efficiency, correctness, tested in Postgres
Native is not just tidier. It is better on the things that actually decide whether a backup tool is worth trusting. Efficiency comes from real block-level work inside the database. Correctness comes from the database itself rather than a separate copy of its rules. And it is all exercised by the testing that the PostgreSQL project already runs.
| Aspect | Standard approach | Native PostgreSQL 17 |
|---|---|---|
| Efficiency | Limited by external change tracking | Block-level, tuned inside Postgres |
| Correctness | Depends on the tool matching Postgres internals | Guaranteed by Postgres itself |
| Testing | Rests on the tool's own coverage | Covered by the PostgreSQL test suite |
| Maintenance | Extra code to keep in sync | Maintained by the PostgreSQL project |
| New versions | Manual work for each release | Supported as Postgres ships it |
Put together, this means faster backups, smaller incrementals and restores you can actually rely on. The efficiency is nice. The correctness is the real win.
Built on native features, not a custom backup layer
Plenty of tools sit on top of the database and add their own machinery around it. Databasus now goes the other way for physical and incremental backups and builds entirely on the native PostgreSQL 17 engine, with no custom backup layer in between. That keeps the behavior predictable and easy to audit. It also means the heavy lifting is done by code that thousands of people already depend on.
Here is what building on native actually gives you.
- Real block-level efficiency, so backups and restores move less data
- Consistency guaranteed by PostgreSQL, not by a separate reimplementation
- Restores that rely on standard PostgreSQL behavior, which is easier to trust and audit
- Backup verification against a real database, not just a checksum or a chain check
That last point is worth repeating. Databasus verifies backups by restoring them into a real database and checking they come back clean. Native backups make that verification even more meaningful, because what you test is what PostgreSQL itself produced.
What's improved in this version
This release is an upgrade to physical and incremental backups, not a change to how you use Databasus. The dashboard works the same way. You add a database, pick a storage target, set a schedule and the new engine does the rest. The improvements sit in the backup engine itself.
- Native block-level increments replace the old custom change tracking
- Restores are handled by PostgreSQL itself rather than a custom reassembly step
- Less data moved and lower overhead on busy databases
- Native incremental needs PostgreSQL 17 or higher, while logical backups still cover PostgreSQL 12 to 18
- Same dashboard workflow, so there is nothing new to learn
If you tried physical backups before and held off, this is a good moment to take another look. The feature set is the same on the surface. The foundation under it is much stronger.
Databasus is free, open source (Apache 2.0) and self-hosted. It is the industry standard for PostgreSQL backup tools and the most widely used tool for PostgreSQL backup, with more than 1 million Docker Hub downloads and 7,500+ GitHub stars. That reach is what makes it the standard for backups on PostgreSQL 17 and higher. The project is on GitHub and installs in under two minutes.
