Watchtower Updated a Container and Broke the Stack: Safer Ways to Keep Docker Images Current
Elena Vasquez
November 16, 2026
Something on your server stopped working overnight. The containers are running, nothing was touched by hand, but the app throws errors, a database refuses to start, or the reverse proxy returns 502s. Then you notice that Watchtower ran at 4 a.m., pulled a new :latest image for one service, recreated it, and deleted the old image afterwards. The stack is now on a version you never chose, and the one that worked is gone. This walkthrough covers how to get back to a working state, why this keeps happening, and the update setups that replace blind auto-updates with something you control.
First, get the broken service back on the previous image
Before changing your update tooling, restore the stack. Start by finding out which service changed and what it was running before.
Watchtower’s own logs usually name the container it updated:
docker logs watchtower --since 24h 2>&1 | grep -i -E "found new|stopping|creating"
Then check what image the affected container is running now:
docker inspect --format '{{.Config.Image}} {{.Image}}' myapp
docker image ls --digests | grep myapp
If Watchtower ran with --cleanup, the previous image has been removed locally, so you cannot simply point the container back at it. You have to pull an older version from the registry by tag. Look up the release history on the project’s GitHub releases page or the registry’s tag list, pick the last version you are confident worked, and pin it in your compose file:
services:
myapp:
image: ghcr.io/example/myapp:2.4.1 # was :latest
Then recreate only that service:
docker compose pull myapp
docker compose up -d myapp
One caveat matters more than any command: if the new version ran a database migration on startup, going back to the old image may not work, because the old code cannot read the new schema. In that case the real rollback is restoring the database or volume from the backup taken before the update. If you had no backup from before 4 a.m., read the project’s upgrade notes; some apps document a downgrade path, many do not. This is the strongest argument against unattended updates of anything with a database.
Watchtower itself is no longer maintained
If you are reconsidering Watchtower, its project status settles part of the question. The original containrrr/watchtower repository was archived by its owner on December 17, 2025, and is now read-only. The README carries a notice that the project is no longer maintained. The maintainers explained in the project’s discussions that they no longer used Docker much and did not have the time or interest to continue. The last upstream release predates the archive by a long way, and no further fixes or security patches are planned. Existing installs keep running, but nothing will change when Docker does.
Docker already did change. Docker Engine 29 raised the minimum API version the daemon accepts, and many users reported the archived Watchtower failing with an error along the lines of client version 1.25 is too old. The commonly reported workaround is setting the DOCKER_API_VERSION environment variable on the Watchtower container to a version the daemon accepts. That works, but it is a patch on an unmaintained tool.
A community fork, nicholas-fedor/watchtower (image nickfedor/watchtower), continues development. Its README says it negotiates the Docker API version automatically, and it positions itself for homelabs rather than commercial production use. If you like Watchtower’s behavior, switching the image to the fork is the smallest change. But the fork does not fix the underlying problem in this article: automatically recreating containers with whatever the registry published last night.
Why :latest plus auto-update is the real failure
Watchtower did exactly what it was told. The fragile part is the combination of a floating tag and an unattended recreate. A tag like :latest or :release points to whatever the maintainer pushed most recently, including major versions with breaking changes, new required environment variables, or a changed database requirement. Nothing in the tag tells you a major jump happened.
Three habits make updates much safer before you even pick a tool:
- Pin a version tag. Use
postgres:16, notpostgres:latest; usemyapp:2.4ormyapp:2.4.1, depending on how much movement you accept. A major-version tag like16still receives minor and patch updates but never jumps to 17 without you editing the file. - Consider pinning a digest for things you never want to change silently.
image: myapp:2.4.1@sha256:...is immutable: even if someone re-pushes the tag, you keep the exact image. - Treat databases differently. Database images should only ever move when you have a fresh dump and have read the upgrade notes. Exclude them from any automatic updater.
Once tags are pinned, “keeping images current” becomes a question of knowing when a new version exists and deciding when to apply it. That is a smaller, safer problem, and several tools solve it well.

Diun: notifications only, nothing gets recreated
Diun (Docker Image Update Notifier) watches the images your containers use and tells you when a registry has something new. It checks for new tags and for digest changes on the tag you run, and it sends a notification through channels such as Discord, Gotify, Pushover, Slack, Telegram and others. It does not pull or restart anything. It is MIT-licensed and runs as a single container.
A minimal setup watches only containers you opt in with a label, on a schedule:
services:
diun:
image: crazymax/diun:latest
command: serve
volumes:
- ./data:/data
- /var/run/docker.sock:/var/run/docker.sock
environment:
- TZ=America/New_York
- DIUN_WATCH_SCHEDULE=0 */6 * * *
- DIUN_PROVIDERS_DOCKER=true
restart: unless-stopped
myapp:
image: ghcr.io/example/myapp:2.4.1
labels:
- diun.enable=true
- diun.watch_repo=true
By default the Docker provider does not watch every container (watchByDefault is false), so the diun.enable=true label opts a service in. With diun.watch_repo=true, Diun watches all tags of the repository, which is what you want when you pin a version: it tells you when 2.5.0 appears even though you run 2.4.1. The diun.include_tags label takes semicolon-separated regular expressions to keep the noise down, for example to ignore release candidates.
Diun suits people who want to decide every update themselves. The cost is that you still have to apply them, which is where a routine comes in.
What’s Up Docker: a dashboard that can also apply updates
What’s Up Docker (WUD) is closer to a replacement for Watchtower, with more control. It scans your containers, compares running tags against the registry with semantic-version awareness, and shows the results in a web UI. Tag filtering rules, such as the wud.tag.include label, limit which tags it considers, so you can, say, accept only 2.x releases for a given service.
What happens when an update is found is decided by triggers. Notification triggers cover a long list of services, including ntfy, Gotify, Discord, Matrix, Telegram and email. There are also action triggers: a Docker trigger that pulls the new image and recreates the container, and a Docker Compose trigger aimed at compose-managed stacks. Triggers can be enabled per container with labels, so you can let WUD auto-update a stateless dashboard while only notifying you about the app with a database. WUD is MIT-licensed and also exposes a Prometheus metrics endpoint if you already monitor the server that way.
The trade-off compared with Diun is surface area: a web UI to secure, more configuration, and the temptation to turn auto-update back on everywhere. Used selectively, it gives you Watchtower’s convenience where it is safe and notifications where it is not.
Renovate: updates as pull requests against your compose files
If your compose files live in a git repository, Renovate turns image updates into reviewable changes. Its Docker Compose manager finds files matching names like compose.yaml and docker-compose.yml, extracts every image, and opens a pull request when a newer version is available. It keeps the precision you used, so myapp:2.4 moves to 2.5, not 2.5.0, and it preserves suffixes such as -alpine. If you pin digests, it can maintain the digest alongside the tag and open PRs when the image behind a tag changes.
That turns every update into a diff with a changelog link that you merge on your own schedule. You can group minor updates, automerge patch or digest bumps for low-risk services, disable major updates for specific images with package rules, and leave databases on manual review. Renovate needs tags that look like versions, which is one more reason to stop using :latest.
Renovate does not deploy anything. After a merge, something still has to pull and recreate on the server: a pull on the host followed by the routine below, a CI job, or a git-driven deploy tool. If you self-host your git, the guide to running Renovate on Forgejo covers the setup end to end.

A manual update routine that leaves a way back
Whether the nudge comes from Diun, WUD or a merged Renovate PR, applying updates by hand once a week takes a few minutes per stack. The point of the routine is to keep the previous image and a backup until you know the new one works.
- Record what is running now.
docker compose imageslists each service’s image and ID. Save it, or rely on git history if your compose files are versioned. - Back up anything with state. Dump databases and snapshot volumes for the stack you are about to touch.
- Edit the pinned tag to the new version and read the release notes for breaking changes.
- Pull, then recreate. Pulling first means a registry outage fails before anything is stopped.
- Check health and logs before moving on to the next stack.
- Prune old images later, not immediately, so a rollback does not need a fresh download.
cd /opt/stacks/myapp
docker compose images > images-before.txt
docker compose pull
docker compose up -d
docker compose ps
docker compose logs --since 10m
# a few days later, once you're confident:
docker image prune
For step 5 to mean anything, your services need real healthchecks rather than “the process is running”. The article on Docker Compose healthchecks explains why a stack can look up before it is ready and how to test for actual readiness.
Rolling back from here is simple because nothing was thrown away: change the tag back to the previous version, run docker compose up -d, and if a migration ran, restore the backup from step 2. That is also why the backup step cannot be skipped for stateful apps; the compose backup guide covers what to copy and how to check it restores.
If you keep Watchtower, narrow what it can touch
Automatic updates are not always wrong. For stateless containers where a broken update costs little, such as a dashboard, a speed-test tool or a status page, auto-update is reasonable. If you keep Watchtower, move to a maintained fork and restrict it. The options below come from Watchtower’s documented flags and labels; forks generally keep them, but confirm against the documentation of the fork and version you run:
--label-enablelimits it to containers labeledcom.centurylinklabs.watchtower.enable=true, so nothing is updated unless you opted it in.--monitor-only, or the per-containercom.centurylinklabs.watchtower.monitor-onlylabel, turns it into a notifier for services you want to update by hand. Note that it still pulls the new image to compare.- Drop
--cleanupif you want the previous image kept locally for a quick rollback, and prune on your own schedule instead. --schedulewith a six-field cron expression runs checks at a time when you are around to notice problems, rather than in the middle of the night.
Combined with pinned major-version tags, this gives you patch updates on low-risk services and a notification for everything else. The broader lesson from the 4 a.m. breakage is the same regardless of tool: an update you did not choose, with no copy of the old version and no backup, is the part to remove. Pin your tags, get notified, apply updates when you can watch them, and keep a way back until the new version has proved itself.