The most expensive mistake in self-hosting is confidence in a backup that has never been restored, and it's number one below because several of the other eleven are only catastrophic when combined with it. All twelve come from my own history or from the weekly confessions on r/selfhosted, and they share one root: trusting a system before you've watched it fail. Here they are, each with the cheap fix.

The data mistakes

1. Backups you've never restored. Eighteen months of family photos, one restic job, zero test restores — then the restore fails on a repository error nobody saw because nothing was checking. The fix costs ten minutes a quarter:

restic -r /mnt/backup/repo restore latest \
  --target /tmp/restore-drill --include /opt/stacks/immich
restic -r /mnt/backup/repo check --read-data-subset=5%

Open a restored file. Actually look at it. The 3-2-1 strategy is the full framework, but the drill is the part that separates a backup from a hope.

2. RAID or sync as backup. RAID survives a disk; it replicates your deletions and your ransomware perfectly. So does Syncthing. If every copy updates within seconds of the original, you have availability, not backup. You need at least one copy that is versioned and delayed.

3. Config that exists only on the server. The machine dies and takes its own documentation with it: compose files, Caddyfile, the crontab, the env vars. Everything that isn't data belongs in a git repo, from day one, so rebuild is git clone plus restore rather than archaeology.

4. Irreplaceable data on the experiment box. The server you tinker on nightly is the least stable machine you own, and it's holding the photos. Separate the roles mentally even on one box: the family-facing stacks get updated deliberately; experiments happen in a VM or on a spare, never with a shared database and never at 11pm before a work trip.

The network mistakes

5. Port-forwarding dashboards to the internet. Forward 8096 "just to test remote access" and Shodan has indexed your login page within days — scanning the whole IPv4 space takes hours in 2026, and unauthenticated dashboards are a browsable catalogue there. Nothing faces the internet except a hardened reverse proxy, and preferably nothing at all: the three remote-access patterns exist so that the answer can be a VPN instead of an open port.

6. Making the family's internet depend on your hobby. Run Pi-hole as the only DNS server and every experiment, reboot, and failed update becomes a household internet outage — the classic "my Docker upgrade broke grandma's tablet". Run a second DNS instance, or make the router's fallback a public resolver, and never hand out a single point of failure via DHCP.

7. Everything by IP and port, forever. 192.168.1.40:8096 works, so you postpone real names and TLS — and each postponement raises the migration cost, until a browser change or an app requiring HTTPS forces it at the worst time. A domain costs ~$10/year and internal names with certificates are a solved, one-evening problem.

8. No monitoring, or monitoring that lives on the patient. You learn things are down from the family, and the monitoring dashboard that would have said why is down with the box hosting it. One outside checker (a status page off-infrastructure) plus one disk-space alert would have pre-empted most of my own incidents; disk-full remains the most preventable outage in the hobby.

The human mistakes

9. Secrets in your head and one browser profile. The server's disk encryption passphrase, the router login, the backup repository password — if any of these exists only in your memory or one synced browser, your household is one accident away from locked-out data. Password manager for everything, plus a printed emergency sheet in an envelope: the backup password especially, since it's the one you'll need on the day the password manager's host is also dead.

10. Migrating the family before it's boring. Kill Google Photos the same week Immich goes up, and every teething problem burns trust you won't get back — one lost upload and they're gone forever. Run new services in parallel for a month; migrate people only after a full cycle of updates and one tested restore has happened without incident.

11. Auto-updating everything, or updating nothing. Nightly :latest pulls on databases eventually eat a breaking change unattended; the opposite sin, eighteen months of no updates, accumulates the compound migration that fails plus every patched CVE. Tier it — auto-update the trivial, schedule the stateful — per updating containers without fires.

12. Buying the rack server first. The $200 R720 is a heater with blades: 100W+ idle (roughly $160/year at $0.15/kWh, double that in Europe), jet-engine fans, and capabilities a home workload touches maybe 5% of. Workload first, hardware second; a used mini PC covers almost everyone, and the money saved buys the backup drive that fixes mistake one.

What I'd do

If you're new: git repo and a tested backup before the third app, VPN instead of open ports, second DNS before the family notices the first, and a mini PC instead of the rack. If you're not new, you read at least three of these with a wince — mine were 1, 6, and 11, and the wince is the tuition. The pattern behind all twelve is the same: assume every component will fail, then check whether the failure is an anecdote or a catastrophe. The whole craft of self-hosting is arranging for anecdotes.