Monitoring stacks have a complexity problem. Prometheus needs cAdvisor, Grafana, node_exporter and Alertmanager. Datadog needs an agent plus a SaaS account. Even "simple" tools like Uptime Kuma need Node.js and a separate database.

That is no longer the only option. Self-hosted tools have matured to the point where a single Go binary can replace a five-container stack. This post looks at what that means in practice, using Maintenant as the example, and at what you give up.

What "single binary" means

A single-binary tool ships as one executable file. No runtime dependencies, no external database, no separate frontend server. The engine, the web interface, the database and the alert system are compiled into one artifact.

In Docker terms: one image, one container, one volume.

services: maintenant: image: ghcr.io/kolapsis/maintenant:latest ports: - "8080:8080" volumes: - /var/run/docker.sock:/var/run/docker.sock:ro - /proc:/host/proc:ro - maintenant-data:/data environment: MAINTENANT_ADDR: "0.0.0.0:8080" MAINTENANT_DB: "/data/maintenant.db" restart: unless-stopped volumes: maintenant-data:

No Postgres container, no Redis container, no nginx in front of it, no separate worker processes.

Three trends that made it practical

  1. Go's embed.FS makes it trivial to ship a full web UI inside a single binary. No separate frontend server needed.
  2. SQLite's WAL mode shows that an embedded database handles real-time workloads (continuous writes plus a live dashboard reading) without PostgreSQL or InfluxDB.
  3. Docker's dominance in self-hosting means a tool can assume a container runtime and skip the "works on bare metal, VMs, containers and Kubernetes" matrix.

The Go advantage

Most single-binary tools are written in Go, for good reasons:

  • Static compilation: no runtime dependencies, no shared libraries.
  • Low memory footprint: goroutines are cheap, garbage collection is efficient.
  • Cross-compilation: one build produces linux/amd64 and linux/arm64 binaries.
  • Embedded assets: embed.FS ships the entire frontend inside the binary.

Maintenant embeds its web UI, its SQLite engine and all its monitoring logic in a single ~20 MB binary, and idles at under 30 MB of RAM.

Fewer failure modes

Every additional component is a potential failure point. Prometheus can crash independently of Grafana. An Alertmanager config can desync from its Prometheus rules. cAdvisor can run out of memory while Grafana keeps showing stale data.

With a single binary, either the whole thing works or it does not. There is no partial failure state to debug.

Simpler backups and updates

There is one SQLite file in one volume. Back it up the way you back up your other volumes: no pg_dump, no TSDB snapshots, no dashboard exports. Updating is docker compose pull && docker compose up -d: one image, one container, no version compatibility matrix between Prometheus, Grafana and their plugins.

The trade-offs

Single-binary tools are opinionated by nature. You trade flexibility for simplicity:

  • No distributed tracing. If you need OpenTelemetry-level observability, this is the wrong class of tool.
  • No infinite retention. Embedded SQLite is not a time-series database tuned for years of data.
  • No custom dashboards and no query language. The views are pre-built; there is no PromQL equivalent and no plugin ecosystem.
  • Scaling limits. One central server with lightweight agents on remote hosts, not a distributed system. Multi-region aggregation remains the domain of distributed stacks.
  • One host to lose. If the machine running it dies, monitoring dies with it. Run it somewhere separate from the infrastructure it watches.

If you manage hundreds of servers across several cloud providers and need ad-hoc queries, a distributed stack is the right tool. For a handful of servers running Docker Compose or single-node Kubernetes, one binary is often enough.

Originally published on maintenant.dev.

Maintenant is an open-source, self-hosted monitoring tool for Docker and Kubernetes: containers, endpoints, cron heartbeats, TLS certificates and alerts, in one container that discovers your stack on its own. Install it in a minute: https://maintenant.dev

This project was funded by the French Government as part of the France 2030 plan operated by Bpifrance.

France 2030 and Cap Digital