saved.sh
DocsPricingDownloadBlog

By source

  • Database backupsPostgres today, on any of the three paths.
  • Files and foldersDirectories on your own hardware. Local path only.
  • Anything you can scriptThe escape hatch, with no reduced guarantees.

By how it runs

  • Backups you driveCLI or API, driven by whatever you already run.
  • Backups on your infrastructureOur worker, your hardware. We never hold the credential.
  • Fully managed backupsWe execute and orchestrate. Nothing to host.
  • Compliance and custodyYour bucket, your account, our orchestration.

Understand it

  • How it worksThree paths, one artifact lifecycle
  • SecurityWhat we can and cannot see
  • CompareAgainst snapshots, cloud-native and scripts
Get started
saved.sh

External backups for the systems a business actually runs on.

A product of reops.

Product

  • Documentation
  • Solutions
  • Compare
  • How it works
  • Security
  • Pricing
  • Download

Developers

  • CLI
  • REST API
  • Recover

Company

  • Blog
  • Privacy
  • Terms

© 2026 saved.sh

Your data survives what holds it.

All postsEngineering

What a run record is for

A directory of files tells you a backup happened. A run record tells you what happened, whether it was complete, and when it stopped being true.

26 July 2026·saved.shView as Markdown

Most homegrown backup setups produce a directory. Files with dates in the names, sorted newest first, and a rough sense that things are fine because the directory is not empty.

A directory answers one question: did something get written. It cannot answer the three that matter when you are staring at it during an incident.

1

Is this file complete, or did the dump die halfway?

2

Is it the size it should be, or the size of an error message?

3

Which run produced it, and did that run succeed?

The empty-file failure

This is the one that gets people, and it is worth describing precisely because it is so undramatic.

pg_dump "$DATABASE_URL" | gzip > backup.sql.gz

If pg_dump fails, it writes an error to stderr and exits non-zero. But the pipeline's exit status is gzip's, and gzip succeeded: it compressed zero bytes into a small, perfectly valid archive. The file exists. It has today's date. It is 20 bytes.

Nothing about the directory listing looks wrong. It will not look wrong tomorrow either, or in eight months when you need it.

Why this survives so long

Every individual night looks the same as a successful one. The failure has no signal of its own, so it is only discovered by the one action nobody performs on a healthy system: actually opening the file.

What we record instead

Every run produces a record, and the artifact is measured rather than assumed.

01

Produced

on your machine

02

Encrypted

your key

03

Uploaded

direct to storage

04

Sealed

under a lock

05

Expired

on schedule

Unreadable from here

The network is crossed here

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.
Each stop is recorded. The size and checksum are taken at seal time, not inferred from the file later.

The record carries what the run did, how long it took, the bytes that arrived, the checksum of what was sealed, and which worker executed it. That turns the three unanswerable questions into a table lookup.

A backup that produced 4 KB where it produced 4.2 GB yesterday is visible in the run history the next morning, not in a year. Not because anything clever is inspecting the contents, but because the number is written down next to the number from last time.

Absence is a signal too

The subtler thing a run record gives you is the ability to notice a run that did not happen.

A cron entry that stops firing produces nothing: no file, no error, no log line, because the thing that would have written them never started. There is no artifact of its absence. A schedule that expects a run can tell the difference between "ran and failed" and "never ran", and those need different responses.

A CRON JOBworker restartsthe run is gone, and nothing says soA DURABLE RUNresumes from the step it reachedcompletes
An interrupted run under a durable engine resumes and completes. Under cron it is simply gone, and gone leaves no evidence.

What it is not

A run record is not verification that the backup restores. Nothing short of restoring it is that, and we would not claim otherwise. What it does is remove the failures that are detectable without a restore, which is most of them, and leave you with the one honest remaining question.

Still worth doing yourself

Restore something into a scratch environment and diff the row counts. Metadata catches the truncated file and the run that never fired. It cannot catch a dump that is complete, well-formed, and of the wrong database.

The directory was never lying to you. It just was not saying anything.

Read next

The connector count is a vanity metric

Every backup vendor advertises how many integrations they have. It is the wrong number, and the moment you need the one they do not support, it is worth exactly nothing.

Backups that survive the thing that took out production.

How it worksStart free