Backups You Already Have and Don't Count
inventory before you buy the number that matters here
By Stan K.
Git is a backup. A SQLite database is one copyable file. Cloud drives keep revisions. Before buying another backup plan, inventory the redundancy you already run — then fill only the actual gaps, 3-2-1-1-0 style.
The instinct when backup anxiety hits is to buy a backup plan. The better first move is an inventory — because most people reading this already run three or four partial backup systems without counting them, and don’t know which gaps remain. Here’s the audit we run on our own machines.
The backups you’re already paying for
Git is a backup of your code. Every push is an off-site copy with full history. If your work is in a repo with a remote, your source is already 2-1: local copy + hosted copy + history. The catch is the unstated stuff — untracked files, .env secrets (rightfully ignored — back those up separately and safely), local databases, generated assets. Git backs up what you commit; it’s worth being honest about what that isn’t.
SQLite is one file. We run several data platforms on SQLite — and a database that is a single file is trivially backup-able: close cleanly or snapshot the WAL, copy the file, done. Compare that to a live Postgres cluster, which needs coordinated dumps or WAL archiving (pgBackRest/WAL-G do this well — the object-storage config is standard). The “boring tech” dividend of SQLite extends to backups.
Cloud sync services keep revisions. Sync is not backup (deletes propagate!), but revision history is a real recovery layer for the synced folder — our own Proton Drive setup versions every board snapshot we upload hourly. Know the retention window of every “sync” product you use; that window is your accidental-delete insurance.
Your package manager and dotfiles. A new machine from scratch costs a day; a scripted machine costs twenty minutes. A setup script in a repo is a logical backup of the machine’s shape even though it backs up no data.
The gaps, named
Run the inventory and the holes get specific fast:
- The single-file databases that only exist locally — SQLite radars, note apps, password vaults. One
cronjob with restic to $6.95/TB storage closes it. - The unsynced creative work — renders, captures, model files too big for sync tiers.
- The machine nobody counts — the homelab box, the NAS (“the NAS is the backup” — of what, and who backs up the NAS?).
- The phone.
3-2-1-1-0, translated for people with a build, not an IT department
The classic rule says three copies, two media, one off-site. The modern extension adds: one immutable/offline copy, and zero errors on restore tests.
Practically, for a builder’s machine:
- 3 copies: working copy + local restic repo (or attached disk) + object-storage repo
- 2 media: the machine’s SSD + the cloud bucket
- 1 off-site: the bucket, automatically
- 1 immutable: Object Lock on the bucket, or
--append-onlyon the rest-server — the ransomware layer explained here - 0 errors: restore something real once a quarter. If the restore has never been attempted, it’s a superstition.
Most inventories end with two cron jobs and one $7/month bucket, not a new $99 plan. The consumer plans earn their price for specific shapes — which shapes, and their exclusions, are itemized here — but they can’t back up what you never inventoried.
Start the audit tonight
- List every service you pay for that stores anything for you (git host, sync drive, email, photo cloud).
- For each, find the revision window. Write the number down.
- Find the data that exists in exactly one place. That list — and nothing else — is your backup project.
- Close it with restic + object storage ($6.95/TB class) and one restore drill.
Tool choices, verified prices and the full plan tables are in the Backups hub; the restore-economics side — what getting data back costs — is the companion piece.