Top 10 Self-Hosted DevOps Tools in 2026 (Portainer & Uptime Kuma)

:::info[Quick Answer] The best self-hosted DevOps tools in 2026 for replacing expensive SaaS subscriptions: Portainer (container management), Uptime Kuma (uptime monitoring), HyperDX (open-source Datadog alternative), Coolify (self-hosted PaaS), and Traefik (reverse proxy). Run them with Docker Compose — you own the data, you skip the monthly bill, and nothing locks you in. :::

SaaS DevOps bills add up fast. Datadog alone can run hundreds per month for a small team. Vercel and Heroku pricing scales with every side project you deploy.

Self-hosting fixes that — if you’re willing to run a VPS and handle your own updates. You get full data control, custom pipelines, and a stack that costs $20–40/month instead of $200+. The trade-off is real: you’re the on-call engineer now.

This guide covers 10 self-hosted tools worth running in 2026, each with a working Docker Compose config. Pair them with a local AI setup (see our Cursor MCP Server guide) and you’ve got a home lab that punches above its weight.

The Stack at a Glance

mindmap
  root((Self-Hosted DevOps Stack))
    Container Orchestration
      Portainer CE
      Coolify PaaS
    Observability & Uptime
      Uptime Kuma
      HyperDX OTel
      Prometheus & Grafana
    Networking & SSL
      Traefik v3 Proxy
    Infrastructure & CI/CD
      OpenTofu IaC
      Argo CD GitOps
      GitLab CI Runners

Pick what you need. Nobody runs all ten on day one — start with Portainer + Uptime Kuma + Traefik and grow from there.

1. Portainer — Docker Without the CLI Headache

Portainer gives you a web UI for Docker containers, Swarm clusters, and Kubernetes namespaces. If you’re tired of typing docker ps and squinting at logs in the terminal, this is the fix.

Docker Compose

version: '3.8'

services:
  portainer:
    image: portainer/portainer-ce:latest
    container_name: portainer
    restart: always
    security_opt:
      - no-new-privileges:true
    ports:
      - "9000:9000"
      - "9443:9443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - portainer_data:/data

volumes:
  portainer_data:

Deploy it:

mkdir -p /opt/portainer && cd /opt/portainer
docker compose up -d

Open http://<server-ip>:9000 and set up your admin account. That’s it — you’re managing containers from a browser now.

When I reach for it: Debugging a container that’s eating RAM at 2 AM. Portainer’s log viewer and resource charts beat SSH tab-hopping every time.

2. Uptime Kuma — Status Pages Without the Pingdom Bill

Uptime Kuma monitors HTTP(s), TCP, Ping, DNS, and Docker container health. Alerts go to Telegram, Discord, Slack, or email. It’s the tool I run on every VPS — takes five minutes to set up, saves you from finding out your site is down via a client message.

Docker Compose

version: '3.8'

services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    restart: always
    ports:
      - "3001:3001"
    volumes:
      - uptime-kuma-data:/app/data

volumes:
  uptime-kuma-data:

docker compose up -d

Hit http://<server-ip>:3001, create an admin account, add your first HTTP monitor. For Discord/Telegram alerting setup, see our dedicated Uptime Kuma guide.

3. HyperDX — Logs, Traces, and Metrics in One Place

HyperDX is the open-source answer to Datadog. It combines logs, traces, and metrics in a single UI backed by ClickHouse. Heavier than Uptime Kuma — budget at least 4 GB RAM.

Docker Compose

version: '3.8'

services:
  hyperdx:
    image: hyperdx/hyperdx:latest
    container_name: hyperdx-app
    restart: always
    ports:
      - "8080:8080"
    environment:
      MONGODB_URI: "mongodb://mongo:27017/hyperdx"
      CLICKHOUSE_HOST: "clickhouse"
    depends_on:
      - mongo
      - clickhouse

  mongo:
    image: mongo:6.0
    container_name: hyperdx-mongo
    volumes:
      - mongo_data:/data/db

  clickhouse:
    image: clickhouse/clickhouse-server:23.8
    container_name: hyperdx-clickhouse
    volumes:
      - clickhouse_data:/var/lib/clickhouse

volumes:
  mongo_data:
  clickhouse_data:

Dashboard lives at http://<server-ip>:8080. Wire your apps to send OpenTelemetry data and you’ve got production-grade observability on a $40 VPS.

4. Coolify — Self-Hosted Heroku/Vercel

Coolify automates Git deployments, SSL certificates, and database provisioning on your own server. Push to GitHub, Coolify builds and deploys. No Vercel bill, no vendor lock-in.

Install

curl -fsSL https://get.coollabs.io/coolify/install.sh | bash

Needs a clean Ubuntu 22.04/24.04 box with SSH access. The installer sets up Docker and the Coolify agent. When it finishes, open http://<server-ip>:8000 and create your admin account.

Coolify vs Portainer: Coolify is for deploying apps (git push → live site). Portainer is for managing containers (logs, networks, resource limits). Different jobs. Most devs want Coolify; most sysadmins want Portainer. Some of us run both.

5. Traefik v3 — Automatic SSL Without Nginx Pain

Traefik watches your Docker containers and provisions Let’s Encrypt certificates automatically. No manual Nginx config files, no certbot cron jobs.

Docker Compose

version: '3.8'

services:
  traefik:
    image: traefik:v3.0
    container_name: traefik
    restart: always
    command:
      - "--api.dashboard=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro

Add Traefik labels to your other services and SSL just happens. Pair this with Coolify or Portainer and your whole stack gets HTTPS for free.

6. OpenTofu — Terraform Without the License Drama

OpenTofu is the Linux Foundation fork of Terraform. Same HCL syntax, same workflow, no BSL licensing concerns. If you’re declaring cloud infrastructure as code, this is the open-source path forward.

Install (Debian/Ubuntu)

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://get.opentofu.org/opentofu.gpg | sudo tee /etc/apt/keyrings/opentofu.gpg > /dev/null
echo "deb [signed-by=/etc/apt/keyrings/opentofu.gpg] https://packages.opentofu.org/opentofu/tofu/any/ any main" | sudo tee /etc/apt/sources.list.d/opentofu.list
sudo apt update && sudo apt install -y tofu

tofu init && tofu plan

If you already know Terraform, you already know OpenTofu. The migration is mostly renaming the binary.

7. Argo CD — GitOps for Kubernetes

Argo CD syncs your Kubernetes cluster state with whatever’s in Git. Push a manifest change, Argo CD applies it. Drift gets flagged automatically.

Worth it if you’re running K8s. Overkill if you’re on plain Docker Compose — skip this until you actually need a cluster.

8. GitLab CI/CD — Pipelines on Your Own Hardware

Self-hosted GitLab gives you source control, container registries, CI runners, and security scanning in one install. Heavy, but if you want GitHub Actions-style pipelines without sending code to Microsoft’s servers, it’s the enterprise option.

9. Netdata — Per-Second Server Metrics, Zero Config

Netdata streams CPU, memory, disk I/O, and network metrics every second. No Prometheus setup, no Grafana dashboards to build first.

wget -O /tmp/netdata-kickstart.sh https://get.netdata.cloud/kickstart.sh && sh /tmp/netdata-kickstart.sh

One command. Dashboard at port 19999. I keep this on every VPS alongside Uptime Kuma — Kuma tells you if something’s down, Netdata tells you why.

10. Penpot — Open-Source Figma

Penpot is a web-based design tool built on SVG, Flexbox, and CSS Grid. Self-host it if your team wants a Figma alternative without per-seat licensing.

Not strictly DevOps — but if you’re building a full stack on one VPS, having design tooling in the same ecosystem keeps everything self-contained.

FAQ

What hardware do I need for this stack?

A 4 vCPU, 8 GB RAM, 50 GB SSD VPS ($20–40/month on DigitalOcean or Vultr) runs Coolify, Traefik, Uptime Kuma, Portainer, and Netdata comfortably. HyperDX wants the full 8 GB — don’t try to squeeze it onto a 2 GB box.

Coolify or Portainer — which first?

Coolify if you’re deploying apps (side projects, client sites, internal tools). Portainer if you’re managing raw Docker infrastructure. Most developers start with Coolify.

How do I back up Docker volumes?

Restic is my go-to — encrypted, incremental, pushes to S3. For a quick manual backup: tar the contents of /var/lib/docker/volumes/ and upload somewhere off-server. Set a cron job or you’ll forget until the disk dies.

What to Read Next

• Production Docker Compose Stack with Traefik & PostgreSQL — wire Traefik + Postgres + backups into one production setup
• Uptime Kuma Docker Setup & Alerting — Discord and Telegram alerts in detail
• Cursor MCP Server Setup Guide — add local AI agents to your self-hosted stack