Isaiah: a self-hosted web UI for managing a Docker fleet

What Isaiah does that a terminal session does not

Isaiah is a self-hostable service for managing Docker resources on a remote server. The README frames it as an attempt at recreating lazydocker from scratch as a web application, without compromising on features. The audience is the person who already administers Docker hosts and wants the same operations from a browser: stacks, containers, images, volumes and networks, each with its own set of actions.

The feature list is concrete rather than aspirational. Stacks support bulk update, pause, unpause, restart and down, plus create and edit from docker-compose.yml files in the browser. Containers support bulk stop, remove, restart, update and prune, along with rename, edit, open in browser, and a shell opened from the browser. Images can be pruned, removed, run as a new container, pulled from Docker Hub, or pulled in bulk. Volumes and networks can be pruned, removed and inspected, and volume files can be browsed through a shell. That is a wide surface, and the README claims it is built on the official Docker SDK for 100% of the Docker features.

One design decision stands out. The client talks exclusively over Websocket, which the README says keeps bandwidth usage very low. The server is written in Go and the client in Vanilla JS, which explains the size claim: a single file executable of about 4 MB and a Docker image of the same order.

How the server, socket and browser fit together

The Dockerfile is four lines and tells you most of the architecture. The build stage is absent from what the repository shows at the top level, but the runtime stage is busybox:stable, the compiled isaiah binary is copied to the image root, an environment variable DOCKER_RUNNING=true is set, and the entrypoint is ./isaiah. There is no Node process, no database container, no reverse proxy bundled in. The whole server is one static binary.

The data flow follows from the deployment command. Isaiah reads the Docker socket mounted into its container, holds the connection open, and pushes state to the browser over the Websocket channel. Actions travel the other way: a click in the browser becomes a Docker SDK call against the socket. The README notes that the tool ships with automatic Docker host discovery, which is why a plain run with no host configuration still finds the local daemon. For anything beyond one machine, the README separates multi-node deployment from multi-host deployment, and the examples directory carries docker-compose.agent.yml and docker-compose.host.yml for those two cases.

Configuration is environment-driven. The README points to a .env file and describes extensive configuration through it, and the example compose files split into supplying variables inline, mounting a .env as a volume, or terminating TLS with certificates mounted as volumes. Authentication has two documented modes: a master password supplied raw or as a sha256 hash, and forward proxy authentication headers for setups like Authelia or Trusted SSO.

Installing Isaiah with Docker and reaching the dashboard

The README states that Docker 23.0.0 or newer must be installed first, and that the Stacks feature needs Docker 26.0.0 or newer. The fastest route is the quick run, which uses the default settings and maps port 3000 to 3000. The default password is documented as one-very-long-and-mysterious-secret, so the first thing to do after logging in is change it.

docker run -v /var/run/docker.sock:/var/run/docker.sock:ro -p 3000:3000 mosswill/isaiah

For anything real, the README recommends an env file. Create an empty .env, fill it in, and pass it with --env-file. The socket is mounted read-only in the documented command, and the container is named mosswill/isaiah. Since version 1.36.2 the images are also mirrored, so ghcr.io/will-moss/isaiah:latest is an alternative source for the same image.

touch .env
docker run \
  --env-file .env \
  -v /var/run/docker.sock:/var/run/docker.sock:ro \
  -p <YOUR-PORT-MAPPING> \
  mosswill/isaiah

If you prefer Compose, the examples directory holds seven files. docker-compose.simple.yml runs Isaiah front-facing on port 80 with variables supplied directly in the file. docker-compose.volume.yml does the same but mounts a .env as a volume, which keeps secrets out of the compose file itself. docker-compose.ssl.yml listens on 443 with a certificate and private key mounted as volumes. docker-compose.proxy.yml and docker-compose.traefik.yml put Isaiah behind a proxy on 443, and the agent and host files cover the multi-node and multi-host cases. After starting, open the mapped port in a browser and log in with the configured password.

The password, the socket and other things the README leaves open

The most obvious limitation is authentication. Isaiah documents a single master password, optionally stored as a sha256 hash, or trust in headers injected by a forward proxy. There is no mention of multiple user accounts, roles, or per-resource permissions. On a shared team, everyone who has the password has every capability in the feature list, including removing volumes and pruning images. If you need to know who deleted a container, this design does not give you that.

The second is the socket. Mounting /var/run/docker.sock gives the container effective control of the Docker daemon, and the README's own commands use :ro. A read-only mount restricts what the daemon exposes, yet the feature list includes removal, pruning and image pulls, which are write operations. The README does not explain how those two facts reconcile, so treat the read-only flag as something to verify against the actions you actually need rather than as a guarantee.

The third is version coupling. Docker 23.0.0 is the floor and 26.0.0 is required for Stacks. Anyone running an older daemon on a long-lived host should check before deploying, because the failure will show up as missing functionality rather than a clean error. There is also no mention of a rollback procedure in what the README covers, and no documented migration path between configuration formats. The README does include a Troubleshoot section and a Security section, so those are the places to look when something misbehaves.

Isaiah against lazydocker and against a plain SSH session

The honest comparison is with lazydocker itself, since Isaiah is explicitly a recreation of it. lazydocker is a terminal application: you install it on the machine where you work, it talks to the Docker socket, and you drive it with the keyboard. Isaiah moves the same class of operations into a browser and puts a server between you and the daemon. That server is the point. It can sit on a host you reach over HTTP or HTTPS, it can serve several people at once, and it can be placed behind a proxy with SSO headers.

The cost is a new component to run and secure. lazydocker needs no listening port and no password because it inherits your shell's access. Isaiah needs a port, a password, and a decision about TLS. The README's proxy example exists precisely because exposing the dashboard directly is a choice you have to make deliberately.

Against a plain SSH session and docker commands, Isaiah wins on inspection speed: live logs, stats, environment variables, full configuration and top output are one click apart, and the built-in terminal emulator means you do not have to leave the browser to open a shell on the server. It loses on scriptability. Nothing in the README suggests a CLI or an API for automation, so anything you need to do in a pipeline stays in your existing tooling.

Licence, releases and what upgrading costs

Isaiah is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. That is the standard permissive arrangement, and it is the whole of what the repository states on the subject. Nothing here is legal advice, and if you redistribute the binary or embed it in a product, read the LICENSE file rather than this paragraph.

The release history is uneven. Version 1.36.2 landed on 2025-07-23, version 1.36.1 on 2025-07-13, and 1.36.9 on 2026-02-28. The last push to the repository was on 2026-07-30, so work has continued past the most recent tagged release. The gap between 1.36.2 and 1.36.9 is roughly seven months with no tagged release in between, which means anyone tracking tags rather than commits can go a long time without a version bump.

Upgrade cost is low by construction. The Docker image is a single binary on busybox, so a new tag is a pull and a restart, and the README's Updating subsection is the place to check for anything beyond that. The risk sits in configuration drift rather than in migration scripts: environment variables drive behaviour, so a new variable in a later version silently takes its default until you add it to your .env. The CHANGELOG.md at the repository root is the file to read before pulling.

Editorial conclusion

Adopt Isaiah if you run Docker on one or more hosts and want a browser interface that covers stacks, containers, images, volumes and networks without giving up shell access to the server. Skip it if you cannot expose port 3000 or a proxy in front of it, or if you need an audit trail of who removed which container, because the README documents a master password and forward proxy headers but no per-user accounts or permission model. Before rolling it out, change the default password, confirm your Docker version meets the 23.0.0 floor (26.0.0+ for Stacks), and decide whether the socket mount stays read-only, since the documented run command uses /var/run/docker.sock:ro while the feature list includes container removal, image pulls and pruning.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. will-moss/isaiah on GitHub