A sanitised reference implementation. Drop it into Claude Code, point it at what your business runs on, adapt the list. Generic on purpose, with no business specifics and no real file names.
The problem
Most small businesses believe they have a backup until the day they need it. Then the copy turns out to be months old, or it was never checked, or nobody knows how to put it back. A backup you have never restored from is a hope, not a backup.
The idea
Every morning, before the day starts, copy everything the business depends on to an encrypted drive you own. That means the databases, taken safely while they are in use, the code with its full history, the settings and the scheduled jobs. Check every copy after it is made. Fingerprint each file and test that each archive opens. Write a manifest of what landed, keep a month of daily copies plus one a month for a year, stay quiet when it works and be loud when it fails. Keep a step by step restore guide on the drive itself, so getting back does not depend on the computer that just died.
07.00 ──> [copy each database safely] ──> [bundle the code with its history, verify]
│
v
[settings and scheduled jobs] ──> [manifest, a fingerprint for every file]
│
v
[keep 30 dailies and 12 monthlies] ──> quiet if clean, loud if not
the restore guide sits on the drive, beside the copies
Minimal reference implementation
# backup_that_proves_itself.py, reference only. Swap in your own list of files.
import hashlib
import sqlite3
import subprocess
def snapshot_database(src, dest):
"""A consistent copy of a live database, taken while the app keeps writing.
Opened read only, so the backup can never change the original."""
source = sqlite3.connect(f"file:{src}?mode=ro", uri=True)
target = sqlite3.connect(dest)
with target:
source.backup(target)
source.close()
target.close()
def fingerprint(path):
"""A SHA-256 per file goes in the manifest, so a later check can prove the
copy is still the copy."""
digest = hashlib.sha256()
with open(path, "rb") as f:
for chunk in iter(lambda: f.read(1 << 20), b""):
digest.update(chunk)
return digest.hexdigest()
def bundle_repo(repo, dest):
"""The whole history in one file, then proved to open."""
subprocess.run(["git", "-C", repo, "bundle", "create", dest, "--all"], check=True)
subprocess.run(["git", "-C", repo, "bundle", "verify", dest], check=True)
Why it works
- Checked, not hoped. Every copy is proved to open, and every file has a fingerprint in the manifest, so the backup tells you it is good rather than asking you to believe it.
- Safe while the business runs. A database copied with its own backup method is consistent even while it is being written to. A plain file copy of a busy database can be quietly broken.
- The way back travels with the copies. A restore guide on the drive means you can recover on a new machine with nothing but the drive and the guide.
- Quiet when fine, loud when not. A daily message saying all is well gets ignored within a week. Silence plus a loud failure is the only pattern that gets read.
- The backup is watched too. A second check looks for the backup's own run each morning, so a backup that stops quietly is caught within a day.
- A drive you own. Your records stay with you, with no monthly fee.
Adapt it
- Write down the three things you could not trade without, and back those up first.
- Practise a restore once, on a spare machine, before you ever need it for real. The guide gets better every time you follow it.
- Keep the drive encrypted, and keep a second copy somewhere else once the first one is running reliably.
Built for my own group of businesses, runs every morning at seven, and this is the generalised version. Take it, point it at what your business runs on, tell me what you would add.