Maintenant is interesting because it tries to compress a whole homelab monitoring shelf into one container.

Maintenant monitors Docker containers, Kubernetes resources, endpoints, TLS certificates, cron-style heartbeats, resource usage, logs, image updates, alerts, and public status pages from one Go service with an embedded Vue dashboard.

That makes it sit somewhere between:

  • Uptime Kuma for availability checks and status pages;
  • Beszel for lightweight host and Docker metrics;
  • a small Prometheus/Grafana/Loki stack for deeper metrics and logs.

The short version:

Maintenant = container discovery + uptime checks + certs + heartbeats + logs + status page + alerts

What is Maintenant?

The repository I checked was:

Repository: https://github.com/kOlapsis/maintenant
Checked commit: cfccc0e81558b1a3a1746455a01a3877f2d897f6
Commit date: 2026-10-01
Container image: ghcr.io/kolapsis/maintenant:latest
Backend: Go
Frontend: Vue 3, TypeScript, Vite, Tailwind CSS
Storage: SQLite by default, PostgreSQL 14+ optional
License model: Apache-2.0 core, commercial source-available paid features

Maintenant ships as a single binary. The Go backend embeds the Vue frontend, talks to Docker or Kubernetes, stores state in SQLite by default, and serves both the private dashboard and the public status page.

There is no required Redis, Prometheus, Grafana, Loki, or external database for the basic install.

Why It Caught My Attention

The usual homelab path is to add tools one by one:

Need Common Tool
Website uptime Uptime Kuma
Host/container resource charts Beszel, Netdata, Glances
Logs Dozzle, Loki
Container updates Watchtower, Diun
Status page Uptime Kuma, Kener
Metrics platform Prometheus + Grafana

Maintenant does not fully replace every specialist in that list. But for a single Docker host or a small Kubernetes setup, it covers a surprisingly wide middle ground with much less wiring.

It can auto-discover containers, show state and health, stream recent logs, track restart loops, create HTTP/TCP endpoint monitors, track TLS certificate expiry, receive heartbeat pings from jobs, build a public status page, send alerts, and show image update/security information.

Self-Hosting Maintenant with Docker

I added a Home-Lab compose folder here:

Home-Lab Maintenant compose

The compose publishes the dashboard on port 3810:

services:
  maintenant:
    image: ${MAINTENANT_IMAGE:-ghcr.io/kolapsis/maintenant:latest}
    container_name: maintenant
    restart: unless-stopped
    read_only: true
    security_opt:
      - no-new-privileges:true
    tmpfs:
      - /tmp:noexec,nosuid,size=64m
    ports:
      - "${MAINTENANT_BIND:-0.0.0.0}:${MAINTENANT_PORT:-3810}:8080"
    environment:
      MAINTENANT_ADDR: "0.0.0.0:8080"
      MAINTENANT_DB: "/data/maintenant.db"
      MAINTENANT_BASE_URL: "${MAINTENANT_BASE_URL:-http://192.168.1.2:3810}"
      MAINTENANT_STATUS_URL: "${MAINTENANT_STATUS_URL:-}"
      MAINTENANT_ORGANISATION_NAME: "${MAINTENANT_ORGANISATION_NAME:-Home Lab}"
      MAINTENANT_DISABLE_TELEMETRY: "${MAINTENANT_DISABLE_TELEMETRY:-true}"
      MAINTENANT_CONTAINER_DOWN_AFTER: "${MAINTENANT_CONTAINER_DOWN_AFTER:-5m}"
      MAINTENANT_PROXY_LABELS: "${MAINTENANT_PROXY_LABELS:-false}"
      MAINTENANT_MCP: "${MAINTENANT_MCP:-false}"
      MAINTENANT_MCP_CLIENT_ID: "${MAINTENANT_MCP_CLIENT_ID:-}"
      MAINTENANT_MCP_CLIENT_SECRET: "${MAINTENANT_MCP_CLIENT_SECRET:-}"
      MAINTENANT_MCP_ALLOWED_REDIRECT_URIS: "${MAINTENANT_MCP_ALLOWED_REDIRECT_URIS:-}"
      MAINTENANT_LICENSE_KEY: "${MAINTENANT_LICENSE_KEY:-}"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /proc:/host/proc:ro
      - /etc/os-release:/host/etc/os-release:ro
      - maintenant-data:/data
    healthcheck:
      test: ["CMD", "/app/maintenant", "healthcheck"]
      interval: 30s
      timeout: 5s
      retries: 5
      start_period: 20s

volumes:
  maintenant-data:

Start it:

cd maintenant
cp .env.sample .env
docker compose up -d

Open:

http://192.168.1.2:3810

For a quick local check:

curl -I http://127.0.0.1:3810/
docker compose ps

Field Note: Local Trial

The Home-Lab compose is intentionally simple:

  • one maintenant container;
  • one persistent Docker volume for /data;
  • SQLite database at /data/maintenant.db;
  • Docker socket mounted read-only;
  • /proc and /etc/os-release mounted read-only for host information;
  • telemetry disabled with MAINTENANT_DISABLE_TELEMETRY=true.

The local test URL is:

http://192.168.1.2:3810

The health endpoint answered:

{"runtime":{"connected":true,"name":"docker"},"status":"ok","storage":{"connected":true,"engine":"sqlite","peers":0},"version":"1.8.1"}

The container healthcheck also became healthy, and the first startup reconciled 70 discovered containers on this host.

There is no setup wizard and no default admin user because Maintenant does not implement its own login system. If you can reach the dashboard, you are effectively an administrator. That is fine for a trusted LAN test, but not for exposing it on the internet.

Where It Fits Beside Uptime Kuma and Beszel

Tool Best For Shape
Uptime Kuma Simple uptime checks, push monitors, status pages, notifications Uptime-first app
Beszel Lightweight host/server monitoring with Docker stats, history, and alerts Hub + agent metrics app
Maintenant Runtime-aware monitoring with containers, endpoints, certs, heartbeats, logs, status pages, alerts, updates, and MCP Single binary / container, optional agents
Prometheus + Grafana Deep metrics, PromQL, exporters, dashboards, long retention Observability platform

Uptime Kuma is still the easiest recommendation when you mostly want to know whether a website, TCP port, DNS resolver, or push monitor is up. It is mature, simple, and already running in this homelab at http://192.168.1.2:3001.

Beszel is cleaner when your main question is: “How are my servers and containers behaving over time?” It has a hub/agent model, Docker statistics, historical metrics, and alerts.

Maintenant is more integrated. It wants to know about the runtime itself, the endpoints, the TLS certificates, the heartbeats, the public status page, the logs, and the update/security state in one place.

For me, the natural split is:

Uptime Kuma = simple external availability
Beszel      = lightweight host/resource history
Maintenant  = container-aware operations dashboard

The Security Catch

This is the most important part: Maintenant has no built-in user accounts and no login page.

The official model is:

Internet -> Reverse proxy -> Auth middleware -> Maintenant

Use something like Authelia, Authentik, OAuth2 Proxy, Cloudflare Access, or your reverse proxy’s authentication layer before exposing the dashboard.

The routes you normally leave public are:

  • /status/* for the public status page;
  • /ping/* for heartbeat monitors;
  • /assets/* if the status page needs the same frontend assets;
  • /mcp, /oauth/*, and /.well-known/* only when HTTP MCP is enabled.

Protect:

/
/api/v1/*

The admin API can read logs, create monitors, acknowledge alerts, configure channels, and manage status-page data.

Docker Socket Note

The compose mounts:

- /var/run/docker.sock:/var/run/docker.sock:ro

That is convenient because Maintenant can discover and inspect local containers.

It is also sensitive. A read-only Docker socket still exposes a lot of operational detail and is often treated as root-equivalent from a security perspective. For a stricter deployment, put a Docker socket proxy between Maintenant and Docker, then allow only the API routes it needs.

FAQ

Conclusion

Maintenant is worth trying if your monitoring stack has become a pile of small tools and you want one place for containers, endpoints, certs, heartbeats, logs, alerts, updates, and a status page.

The trade-off is clear: because there is no built-in login, you must handle authentication at the reverse proxy. For a LAN-only homelab test, that is fine. For internet exposure, it is mandatory.

I would not remove Uptime Kuma yet. I would run Maintenant beside it first and see whether its runtime-aware view reduces the number of separate dashboards I actually open.