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 composeThe 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
maintenantcontainer; - one persistent Docker volume for
/data; - SQLite database at
/data/maintenant.db; - Docker socket mounted read-only;
/procand/etc/os-releasemounted 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
Where can I see the UI in this homelab?
For this local compose:
http://192.168.1.2:3810
Folio, from the previous review, is still on:
http://192.168.1.2:4870
Maintenant has no default username or password. Put it behind reverse-proxy authentication before exposing it beyond the LAN.
Does Maintenant replace Uptime Kuma?
Not exactly.
Maintenant overlaps with Uptime Kuma on HTTP/TCP checks, heartbeats, TLS certificates, alerts, and status pages.
Uptime Kuma is still simpler when all you need is a reliable uptime dashboard and notification system. Maintenant becomes more compelling when you also want container discovery, container health, logs, image update detection, Docker/Kubernetes context, and runtime security insights in the same UI.
How does Maintenant compare with Beszel?
Beszel is a lightweight server monitoring platform with Docker statistics, historical data, and alerts. Its model is a hub plus agents, where the agent runs on each system being monitored and reports system metrics back to the hub.
Maintenant is broader around operational checks: endpoints, certificates, heartbeats, status-page components, live container logs, image updates, alerts, Docker/Kubernetes discovery, and optional MCP access.
I would think of Beszel as the clean resource-history dashboard and Maintenant as the container-aware operations console.
Can it monitor Kubernetes too?
Yes. The project ships Kubernetes manifests and a Helm deployment path, and the code uses the Kubernetes client libraries. It can list namespaces, workloads, pods, nodes, and Kubernetes-related runtime state.
For a small Docker homelab, the Docker socket path is easier. For a cluster, deploy it with Kubernetes-native permissions and scope the namespaces intentionally.
Does it need an external database?
No.
Maintenant uses SQLite by default, stored at /data/maintenant.db in the container. PostgreSQL 14+ is optional through MAINTENANT_DATABASE_URL.
There is no Redis, queue, Prometheus, or Grafana requirement for the default setup.
What data should I back up?
Back up the persistent data volume:
maintenant-data
That contains the SQLite database, license cache, telemetry identity when telemetry is enabled, and embedded-agent data. If you switch to PostgreSQL, back up the database and still keep the /data directory for local runtime files.
What about telemetry?
Upstream telemetry is opt-out. The docs say the snapshot is anonymous and does not include hostnames, IPs, container names, endpoint URLs, certificates, webhook targets, status component names, license keys, or free-form strings.
For the Home-Lab compose, I set:
MAINTENANT_DISABLE_TELEMETRY=true
That keeps the local trial quiet by default.
Is it fully open source?
It is not a plain single-license FOSS project in the same way Uptime Kuma is.
The core is Apache-2.0, but the repository also contains commercial source-available code under internal/commercial/ and frontend/src/commercial/. Features are gated by Community, Personal, and Pro editions.
For homelab writing, I would describe it as Apache-2.0 core with paid source-available features.
What do the paid editions unlock?
Community covers the basics: containers, endpoints, heartbeats, certificates, public status page, Swarm/Kubernetes views, and limited resource history.
Personal lifts several limits and adds features such as remote hosts, more alert channels, CVE enrichment, security posture, incidents, changelog, and longer history.
Pro targets team/employer/third-party use and adds broader multi-host, notification, status-page, branding, subscriber, escalation, and retention capabilities.
Check the upstream edition table before relying on a paid feature, because limits can change.
What is the MCP feature for?
Maintenant embeds an MCP server so tools like Claude, Cursor, Codex, or other MCP clients can query monitoring data.
The HTTP MCP mode requires MAINTENANT_MCP=true and OAuth-style client credentials:
MAINTENANT_MCP=true
MAINTENANT_MCP_CLIENT_ID=maintenant-mcp
MAINTENANT_MCP_CLIENT_SECRET=use-a-long-random-secret
MAINTENANT_BASE_URL=https://maintenant.example.com
There is also a local stdio mode for trusted local clients. Do not expose unauthenticated HTTP MCP unless it is on a trusted private network.
Could this replace Prometheus and Grafana?
For basic homelab infrastructure monitoring, maybe.
For application metrics, PromQL, exporters, alert rules across custom metrics, long-term metric retention, and deep dashboards, no. Prometheus and Grafana remain the correct toolchain when you need a real metrics platform.
Maintenant is more of an operations dashboard than a full observability backend.
What did the local run reveal about this homelab?
The first local run connected to Docker, used SQLite, discovered 70 containers, and started the dashboard successfully on port 3810.
It also immediately produced security insights for many containers. Most of the early findings are expected in a homelab where services are intentionally published on LAN-facing ports. Upstream explicitly notes that publishing Maintenant itself on all interfaces can be reported as a critical exposure, because the scanner is reporting what it sees rather than guessing whether the LAN is trusted.
That makes the security page useful as a review checklist, not an automatic instruction to shut everything down.
Why did I see incidents and warnings right away?
Because Maintenant was allowed to inspect the whole Docker host, not only the app we just installed.
On this homelab run it reported:
Active alerts: 50
Security dangerous-configuration alerts: 14
Container-down alerts: 6
Image-update alerts: 30
Security insights: 65 across 52 containers
The noisy-looking numbers came from normal homelab reality:
- old trial containers that were stopped but still existed;
- services intentionally published on LAN ports;
- database ports from old trial stacks;
- containers using host networking;
- images with newer versions available upstream.
That does not mean the server suddenly became broken. It means Maintenant is reading Docker state and reporting what it sees.
What kinds of flags did Maintenant help discover?
In this local run, the useful categories were:
| Finding | What It Means |
|---|---|
container_down |
A container has been exited longer than the configured threshold, here 5 minutes. |
port_exposed_all_interfaces |
A service is bound to 0.0.0.0, so it listens on every host interface. |
database_port_exposed |
A database such as MySQL/MariaDB or Redis is reachable on a host port. |
host_network_mode |
A container shares the host network namespace. |
update_available |
The container image appears to have a newer version available. |
The most actionable ones are usually exposed database ports and old stopped trial containers. LAN-published web UIs are not always wrong, but they should be intentional.
How can I reduce noisy warnings?
Start with cleanup:
docker ps -a
docker compose down
docker rm <old-container>
Then tighten exposure:
- bind private dashboards to
127.0.0.1when they only need a local reverse proxy; - avoid publishing database ports unless you actively need host access;
- prefer internal Docker networks for app-to-database traffic;
- avoid
network_mode: hostunless the app really needs it; - put public services behind a reverse proxy with HTTPS and authentication where appropriate;
- stop or remove review containers when the review is done;
- acknowledge expected findings in Maintenant rather than treating every LAN port as an emergency.
For example, a private app behind a reverse proxy can use:
ports:
- "127.0.0.1:3811:3000"
instead of:
ports:
- "0.0.0.0:3811:3000"
The second form is convenient for LAN testing, but it is exactly what Maintenant should flag.
Does Maintenant update containers like Watchtower?
No, not by default.
Maintenant can detect and notify that newer image versions are available. That is different from automatically pulling and restarting containers.
Watchtower is the tool in this ecosystem that can automatically update running containers. That automation is convenient, but it can also surprise you if a breaking image gets pulled while you are not watching.
I see the relationship like this:
Maintenant = tell me what is outdated
Watchtower = update containers automatically
Diun = notify about image updates without applying them
For important services, I prefer Maintenant or Diun-style notification first, then manual updates with a quick backup. For disposable apps or low-risk services, Watchtower can be acceptable.
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.
Comments