Updating Self Hosted Containers Without Breaking Them
Nothing on the server is broken, which is exactly why the Nextcloud container on mine spent fourteen months running an image I pulled once and forgot. There is no update prompt on a home server.

Nothing on the server is broken, which is exactly why the Nextcloud container on mine spent fourteen months running an image I pulled once and forgot. There is no update prompt on a home server. No nag screen, no red badge, no phone call from a vendor. Files keep syncing, the dashboard keeps loading, and the gap between what you run and what upstream has already patched grows quietly until an advisory lands with your exact version number printed in it.
I have failed at this in both directions. For about two years I let Watchtower pull the latest image for everything every night, and twice it took down a service on the one evening I needed it. Then I overcorrected and froze the whole stack, which is the worse of the two mistakes. What follows is the middle path I run now across eleven containers on a single mini PC: tags pinned at the level each project has earned, one short window a week, and a rollback I have actually rehearsed.
The latest tag hides the one fact you need
A tag is a label, not a version. When a project pushes a new build to latest, the old image keeps its digest but loses its name. Six weeks later you run docker image inspect, get back a sha256 string, and have no idea whether that string was 2.4.1 or 2.7.0. Reading the changelog turns into guesswork, and the changelog is the only place anyone warns you that a startup migration rewrites the database.
That migration is the real risk, not the download. Paperless-ngx going from 1.x to 2.x rebuilt its search index on first boot. Immich changed its database layout several times across 2024, and the release notes said plainly that going backwards needed a restore from backup. An unattended nightly pull turns a documented one way door into something that happens while you are asleep.
Security pushes the other way, and it pushes hard. Most of what we self host comes from teams of two or three people, and a fix for an authentication bypass often ships as a patch release with three lines of notes and no fanfare. Freeze your images to avoid breakage and you are also sitting on those three lines. The checklist before exposing a home server online is worth very little if the thing you exposed is eight releases behind.
Pin to the level the project has earned
Not every service deserves the same trust. I kept a plain text log of my own breakages for a year, and the pattern that fell out of it was simple: the more state a service owns, the tighter I pin it. My stack now sorts into four treatments.
| Service type | Tag I follow | How it updates | Reason |
|---|---|---|---|
| Stateless tools such as Uptime Kuma | major, like 1 | automatic, weekly | a bad build costs me a restart |
| Reverse proxy, Caddy or Traefik | minor, like 2.8 | manual, monthly | config syntax shifts between minors |
| Photo and document stores | exact, like 1.119.0 | manual, after reading notes | startup migrations touch the database |
| Postgres and MariaDB | major only, like 16 | manual, planned in advance | a major bump needs a dump and reload |
Three of those rows are boring. The database row is the one people get caught by, because Postgres refuses to start on a data directory written by a newer binary and the container simply restart loops with a message most of us do not read on the first try. I lost an evening to that in 2023. Now any database major version is its own small project, with a dump taken minutes beforehand and nothing else changing that day.
For the manual half I settled on Diun. It watches the registry for the tags you follow and sends a notification when a new one appears, and it changes nothing by itself. That split is the whole design: automation tells me something is available, and a person decides whether the house is quiet enough to apply it.
The counter take: do not automate your application updates
Forum advice says automatic updates are always the safer choice, because humans procrastinate. I think that is correct for the operating system and wrong for the applications, and the two get flattened into one slogan far too often.
On the host I run unattended upgrades for security packages only, with automatic reboots switched off. Those patches come from a distribution that tested them against the same package set I have, they rarely change behaviour, and they cover precisely the code an unauthenticated stranger reaches first: OpenSSH, the kernel network stack, the TLS libraries. In four years that has not broken anything on my box.
Application containers are a different animal. The person pushing that image does not know which plugins you enabled, which proxy header you added by hand, or that the phone client in your pocket is two versions behind the server. A failed OS patch usually means a package stays where it was. A failed app update can mean a half migrated database and a restore. Those are not the same bet, and one checkbox labelled auto update should not cover both.
I do make one exception, and it is about blast radius rather than principle. Anything with no persistent volume updates itself, because the worst case is a container that will not start and a service I can live without until Sunday.
A twenty minute window beats a perfect schedule
Sunday morning, coffee, roughly twenty minutes. The predictability is what makes this survive contact with real life, far more than any tooling choice.
I start by reading the notifications Diun sent during the week, usually four or five of them, and I open the release notes for anything that is not a patch bump. Any note containing the words migration, breaking or schema gets pushed to a day when I have a spare hour instead of twenty minutes.
Then a snapshot. All my compose files and volume paths sit under one directory, and the restic job I use on this server runs manually before I touch anything. On a 40 GB dataset it finishes in about ninety seconds, because almost nothing has changed since the night before.
Then I pull and recreate one service at a time, waiting for its health check to come back green before starting the next. Doing all eleven at once saves maybe four minutes and costs an hour when something fails, because you have thrown away the one piece of information that would tell you which change did it.
Last, I open two things in a private browser window: the service itself, and whatever talks to it. The Immich phone app has broken on me after a server update that looked completely fine in a browser, and that is the kind of thing nobody reports until the holiday photos stop uploading.
Write down what you did. Mine is one text file per server with a date, the service, the old version and the new one. It has paid for itself twice, both times by answering the question of when a problem started in under a minute.
Rolling back without panic
If the tag is pinned, a rollback is one edit and one command. Change the version in the compose file back, run up with the detach flag, and the old image comes out of the local cache. This only works if the image is still on disk, so be careful with docker image prune and the all flag, which cheerfully deletes the exact layer you are about to want. I keep two versions of anything stateful and let the rest go.
When the data has already been migrated, no tag change saves you. That is a restore: stop the stack, move the volume aside rather than deleting it, restore the snapshot, start the old image. Moving the broken volume instead of removing it has twice let me go back and read a log file that explained what actually happened.
One detail that wastes people a lot of time: after a rollback, the proxy may still be holding a connection to a container that no longer exists, and the browser shows a 502 that has nothing to do with the app. Restart the proxy before you conclude the restore failed. If yours is new, picking a reverse proxy for a home server covers which ones re-resolve container names on their own.
Pick one service this week, look up what version you are actually running, and pin it. That single act turns every future update from a surprise into a decision.
FAQ
How often should I update a self hosted server?
Weekly for the host security packages, weekly for anything stateless, and monthly for the rest unless an advisory names your version. The interval matters less than having a fixed slot you keep.
Is Watchtower safe to use?
It is safe on containers that own no data and risky on the ones that do. I still run it, scoped by label to four stateless services, with notifications on and cleanup enabled.
Do I need to update something that is not reachable from the internet?
Yes, though with less urgency. A LAN only service is still reachable by any device on your network, including a laptop that picked something up elsewhere, and by anything running in your browser.
How do I know whether an update will change the database?
Read the release notes for the words migration, schema and index, and check whether the project publishes a downgrade path. If there is no documented way back, take the backup first and update on a day you have time.
More in Self Hosting
Self Hosting
Dynamic DNS Setup to Reach Your Home Server by Name
The server at home is fine. The router is fine. What broke is the sentence you memorised two months ago, the one with four...
Self Hosting
Minecraft Server on a Mini PC: RAM, Flags and Backups
The server my friends play on is a fanless Intel N100 mini PC that cost $155, sits on a shelf behind the router, and has been...
Self Hosting
Authelia Setup to Add Two Factor Login to Home Server Apps
You finally got Jellyfin, Paperless and a dashboard reachable from outside the house, and each one has its own login page, its...