Monitor everything. Manage nothing.
Drop a single container. Your entire stack is monitored in seconds.

Documentation  •  Quick Start  •  Features  •  Pricing  •  Configuration  •  API

Most self-hosters juggle 3-5 tools to monitor their stack: one for containers, one for uptime, one for certs, one for metrics, and yet another for a status page. maintenant replaces all of them.

One container. One dashboard. Everything monitored.

Dashboard — Uptime, response times, resources, unified monitors
Container auto-discovery	Endpoint monitoring
TLS certificate tracking	Update intelligence
Status page — All operational	Status page — Degraded state

# docker-compose.yml
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:

docker compose up -d

Open http://localhost:8080 — your containers are already there. No configuration needed.

kubectl apply -f deploy/kubernetes/

maintenant auto-detects the in-cluster API. Read-only RBAC, namespace filtering, workload-level monitoring out of the box.

For detailed setup instructions, advanced configuration, and label reference, see the full documentation.

Zero-config auto-discovery for Docker and Kubernetes. Every container is tracked the moment it starts — state changes, health checks, restart loops, log streaming with stdout/stderr demux. Compose projects are auto-grouped. Kubernetes workloads (Deployments, DaemonSets, StatefulSets) are first-class citizens.

Define HTTP or TCP checks directly as Docker labels — no config files, no UI clicks. maintenant picks them up automatically when a container starts. Response times, uptime history, 90-day sparklines, configurable failure/recovery thresholds.

labels:
  maintenant.endpoint.http: "https://api:3000/health"
  maintenant.endpoint.interval: "15s"
  maintenant.endpoint.failure-threshold: "3"

Create a monitor, get a unique URL, add one curl to your cron job. maintenant tracks start/finish times, durations, exit codes, and alerts you when a job misses its deadline.

# One-liner for any cron job
curl -fsS -o /dev/null https://now.example.com/ping/{uuid}/$?

Community includes up to 5 heartbeats. Pro lifts the cap for unlimited jobs.

Automatic detection from your HTTPS endpoints, plus standalone monitors for any domain. Alerts at 30, 14, 7, 3, and 1 day before expiry. Full chain validation.

Real-time CPU, memory, network I/O, and disk I/O per container. Historical charts from 1 hour to 30 days (Pro). Per-container alert thresholds with debounce to avoid noise. Top consumers view for instant triage.

Automatic detection of dangerous network configurations across your containers. Flags ports binding to 0.0.0.0, exposed database ports, host-network mode, privileged containers, and Kubernetes-specific risks (NodePort, LoadBalancer without NetworkPolicy). Each container image is mapped to its software ecosystem via OCI manifest inspection for CVE-relevant context.

Knows when your images have updates available. Scans OCI registries, compares digests. Compose-aware update and rollback commands with the correct --project-directory flag. Stop running docker pull blindly.

Unified alerts across all monitoring sources. Webhook and Discord channels included. Silence rules for planned maintenance. Exponential backoff retry on delivery.

Pro adds Slack, Microsoft Teams, and Email channels, plus escalation chains and maintenance windows.

Give your users a clean, real-time status page. Component groups, live SSE updates, severity aggregation across all monitors.

Pro adds incident timelines and subscriber notifications (email + webhook) — turn outages into trust-building moments.

Built-in Model Context Protocol server. Query your infrastructure, read logs, and check alert status from any MCP-compatible AI assistant. Supports both stdio and Streamable HTTP transports with full OAuth2 authentication for remote clients (Claude web, Claude mobile, Claude Desktop).

Full configuration reference in the documentation.

labels:
  maintenant.ignore: "true"                    # Exclude from monitoring
  maintenant.group: "backend"                  # Custom group name
  maintenant.alert.severity: "critical"        # critical | warning | info
  maintenant.alert.restart_threshold: "5"      # Restart loop threshold
  maintenant.alert.channels: "ops-webhook"     # Route to specific channels

labels:
  # Simple — one endpoint per container
  maintenant.endpoint.http: "https://app:8443/health"
  maintenant.endpoint.tcp: "db:5432"

  # Indexed — multiple endpoints per container
  maintenant.endpoint.0.http: "https://app:8443/health"
  maintenant.endpoint.1.tcp: "redis:6379"

  # Tuning
  maintenant.endpoint.interval: "30s"
  maintenant.endpoint.timeout: "10s"
  maintenant.endpoint.http.method: "POST"
  maintenant.endpoint.http.expected-status: "200,201"
  maintenant.endpoint.http.tls-verify: "false"
  maintenant.endpoint.http.headers: '{"Authorization":"Bearer tok"}'
  maintenant.endpoint.failure-threshold: "3"
  maintenant.endpoint.recovery-threshold: "2"

labels:
  maintenant.tls.certificates: "example.com:443,api.example.com:443"

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"

  api:
    image: myapp:latest
    labels:
      maintenant.group: "production"
      maintenant.endpoint.http: "http://api:3000/health"
      maintenant.endpoint.interval: "15s"
      maintenant.alert.severity: "critical"
      maintenant.alert.channels: "ops-webhook"

  postgres:
    image: postgres:16
    labels:
      maintenant.endpoint.tcp: "postgres:5432"
      maintenant.alert.severity: "critical"

  redis:
    image: redis:7-alpine
    labels:
      maintenant.endpoint.tcp: "redis:6379"

volumes:
  maintenant-data:

maintenant sends an anonymous, opt-out usage snapshot once an hour to https://metrics.kolapsis.com. No hostnames, IPs, container names, endpoint URLs, certificates, webhook targets, status-page component names, license keys, or operator-supplied free-form strings of any kind are transmitted.

Each snapshot contains the following fields and nothing else (full wire format: specs/015-shm-telemetry/contracts/telemetry-payload.md):

Application fields (this product owns these):

• edition — community or pro
• containers_total — count of auto-discovered containers
• endpoints_total — count of configured HTTP/TCP endpoints
• heartbeats_total — count of configured heartbeat monitors
• certificates_total — count of TLS certificate monitors
• webhooks_total — count of configured webhooks
• status_components_total — count of status-page components

Runtime context (collected automatically by the SHM SDK):

• sys_os, sys_arch, sys_cpu_cores, sys_go_version, sys_mode (docker / kubernetes / standalone)
• app_mem_alloc_mb, app_goroutines, app_uptime_h
• An installation identifier generated by the SDK on first run and reused thereafter

Set MAINTENANT_DISABLE_TELEMETRY to a truthy value before the process starts:

# Docker
docker run -e MAINTENANT_DISABLE_TELEMETRY=1 ghcr.io/kolapsis/maintenant:latest

# Kubernetes
env:
  - name: MAINTENANT_DISABLE_TELEMETRY
    value: "1"

# systemd / shell
export MAINTENANT_DISABLE_TELEMETRY=1
./maintenant

Truthy values (case-insensitive, whitespace-trimmed): 1, t, true, y, yes, on. Anything else, including empty or unset, leaves telemetry enabled.

When disabled, exactly one log line is emitted at startup and nothing else:

INFO  telemetry disabled  reason=opt-out

No background goroutine, no DNS lookup of metrics.kolapsis.com, no outbound packets toward it.

The SDK persists its identity to /data/shm/shm_identity.json on first run. Mount a persistent volume on /data/shm so the same installation isn't counted as new on every restart.

The reference Docker Compose template above already mounts /data as a volume — /data/shm is a subpath, so it's covered by default. For Kubernetes:

apiVersion: apps/v1
kind: StatefulSet
spec:
  template:
    spec:
      containers:
        - name: maintenant
          volumeMounts:
            - name: shm-data
              mountPath: /data/shm
  volumeClaimTemplates:
    - metadata:
        name: shm-data
      spec:
        accessModes: [ReadWriteOnce]
        resources:
          requests:
            storage: 100Mi

Without the volume, every restart is counted as a fresh install. The privacy impact is zero (the identity is opaque), but our fleet stats will be distorted — please keep the volume.

When /data/shm is unwritable (read-only mount, permission error), telemetry disables itself silently with a single WARN line:

WARN  telemetry disabled  reason=datadir-unwritable  datadir=/data/shm  error=...

We deliberately don't fall back to an in-memory identity — that would inflate fleet-wide install counts.

maintenant does not include built-in authentication — by design.

Like Dozzle, Prometheus, and most self-hosted monitoring tools, maintenant is designed to sit behind your existing reverse proxy + auth middleware. No need to manage yet another set of user accounts.

Internet  ->  Reverse Proxy (Traefik / Caddy / nginx)
          ->  Auth (Authelia / Authentik / OAuth2 Proxy)
          ->  maintenant

services:
  maintenant:
    image: ghcr.io/kolapsis/maintenant:latest
    labels:
      traefik.enable: "true"
      traefik.http.routers.maintenant.rule: "Host(`now.example.com`)"
      traefik.http.routers.maintenant.middlewares: "authelia@docker"
    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"
      MAINTENANT_BASE_URL: "https://now.example.com"

Note: /ping/{uuid} (heartbeat pings) and /status/ (public status page) are meant to be publicly accessible. Configure your proxy rules accordingly.

Deliver to Discord or any HTTP webhook. Slack, Teams, and email available with maintenant Pro.

Full REST API under /api/v1/ for automation and integration.

┌──────────────────────────────────────────────────────┐
│                  Single Go Binary                    │
│                                                      │
│   ┌────────────────────────────────────────────┐     │
│   │  Vue 3 + TypeScript + Tailwind (embed.FS)  │     │
│   │  Real-time SSE  ·  uPlot charts  ·  PWA    │     │
│   └────────────────────────────────────────────┘     │
│                         |                            │
│   ┌────────────────────────────────────────────┐     │
│   │           REST API v1 + SSE Broker         │     │
│   └────────────────────────────────────────────┘     │
│          |                          |                │
│   ┌─────────────┐  ┌──────────────────────┐         │
│   │   Docker     │  │     Kubernetes       │         │
│   │   Runtime    │  │     Runtime          │         │
│   └─────────────┘  └──────────────────────┘         │
│          |                          |                │
│   ┌────────────────────────────────────────────┐     │
│   │  Containers · Endpoints · Heartbeats ·     │     │
│   │  Certificates · Resources · Alerts ·       │     │
│   │  Updates · Security · Status Page ·        │     │
│   │  Webhooks                                  │     │
│   └────────────────────────────────────────────┘     │
│                         |                            │
│   ┌────────────────────────────────────────────┐     │
│   │     SQLite  (WAL · single-writer · zero    │     │
│   │              external dependencies)        │     │
│   └────────────────────────────────────────────┘     │
└──────────────────────────────────────────────────────┘

• Single binary — Frontend embedded via embed.FS. One file to deploy.
• Zero dependencies — SQLite is the only database. No Redis, no Postgres, no message queue.
• Real-time — SSE pushes every state change to the browser instantly.
• Read-only — maintenant never touches your containers. Observe only.
• Label-driven — Configure monitoring through Docker labels. No YAML to maintain.
• ~17 MB RAM — Lightweight enough to run on any VPS or Raspberry Pi.

Community Edition is free forever. Pro keeps the project alive.
_{If you ship real software, €29/mo is less than two hours of debugging the outage you didn't see coming.
And 100% of revenue funds full-time development — no investors to pay back, no salespeople to feed.}

• Sleep through the night. Escalation chains page the on-call engineer, then the backup, then the lead — instead of dying silently in a muted Discord.
• Prioritize the vulnerabilities that matter. CVE enrichment and per-container risk scoring surface what's critical in your environment — not a generic feed.
• Turn outages into trust. Public incident timelines and subscriber notifications keep your users informed automatically.
• Get direct answers. Priority email support, straight to the developer who wrote it.
• Fund independent software. maintenant is built in Bordeaux, France — by one developer, with no VC, no tracking, no dark patterns. Your subscription is the roadmap.

_{Pro — Unified security posture with CVE enrichment & risk scoring}

Pick the processor that fits where you are:

• 14-day free trial — plenty of time to evaluate against a real stack
• Cancel anytime from your dashboard
• VAT-compliant invoices issued automatically
• Self-hosted means self-hosted — your monitoring data never leaves your infrastructure

Fair question. Here's the honest answer:

Grab a key from maintenant.dev/#pricing, set it in your environment, restart — done.

MAINTENANT_LICENSE_KEY=your-license-key

_{14-day free trial · cancel anytime · VAT-compliant invoices}

maintenant is built independently in Bordeaux, France. No VC, no tracking, no telemetry, no data collection, no acquisition exit. The only way this keeps going is if users who benefit from it give back. Here's how, ranked by impact:

_{Every Pro subscriber and GitHub sponsor keeps this project independent. Thank you.}

Want your company logo here? Become a corporate sponsor — visibility for you, runway for the project.

Code contributions are welcome. Please open an issue first to discuss bigger changes. Small fixes, typos, docs — just send the PR.

For other ways to contribute (bug reports, feature ideas, feedback), see Support the project.

Copyright 2025-2026 Benjamin Touchard / kOlapsis — Bordeaux, France

Licensed under the GNU Affero General Public License v3.0 (AGPL-3.0) or a commercial license.

_{Built with care in Bordeaux, France — if maintenant saves you an outage, buy the developer a coffee (or a year of runway).}