XDA covered a home-lab tool this month called Pulse, and half of r/selfhosted spent the week ripping Uptime Kuma out of their Proxmox, Docker, and TrueNAS setups to try it. Uptime Kuma is still the tool we recommend for anyone spinning up a first status page. It installs in one Docker command, the UI makes sense in five minutes, and the free monitor count is generous.
Once we crossed about thirty checks, though, the walls showed up fast. Single node, no clustering, no built-in Prometheus scrape endpoint, and the check types are basically ping and HTTP. If we wanted CPU, memory, or disk graphs per host, we had to bolt on a second tool. The dashboard is functional, not something we want to project on a wall.
We tested seven self-hosted alternatives on Debian 12, Docker Compose, and a small Proxmox cluster. Here is how they compare.
Quick comparison
| App | Best for | Free plan | Starting price | Standout feature |
|---|---|---|---|---|
| Pulse | Proxmox + Docker + TrueNAS in one pane | Full free | Free (donations) | Unified home-lab dashboard |
| Beszel | Kuma users who want host metrics | Full free | Free | Tiny Go agent, pretty UI |
| Gatus | YAML-defined health checks | Full free | Free | Endpoint checks in code |
| Statping-ng | Public status pages | Full free | Free | Themeable status page |
| Checkmk Raw | 50+ node fleets | Full free (Raw) | Around $600/yr (Enterprise) | Deep plugin ecosystem |
| Zabbix | Enterprise depth on a home budget | Full free | Free (paid support) | Any metric, any trigger |
| Netdata | Real-time troubleshooting | Full free (self-hosted) | Around $3/node/month (Cloud) | Per-second resolution |
Why home labs outgrow Uptime Kuma
The pattern shows up in the same forum threads every month. Someone posts a dashboard with fifty monitors, mentions their SQLite database is locking during ping sweeps, and asks what to switch to. Kuma’s storage layer was not designed for high-frequency writes across dozens of checks, and there is no clustering option to spread the load.
The bigger gap is scope. Kuma probes services from the outside. It cannot tell us that a Proxmox node’s ZFS pool is at 87 percent, that a Docker host is swapping, or that a Raspberry Pi’s SD card is throwing read errors. Those are host-level facts, and getting them requires an agent running on the machine, which Kuma has never shipped.
Notifications are the third snag. Kuma covers the basics (Discord, Telegram, email, generic webhooks), but there is no concept of rules, silences, or on-call rotation. If we want to page a specific person between 22:00 and 06:00 only when three checks fail in a row, we end up writing that logic in a webhook receiver.
Finally, no first-class Prometheus scrape. There is a community endpoint, but if our stack already runs Grafana on top of Prometheus, we usually want the monitoring tool to expose metrics natively.
The alternatives
Pulse, the XDA pick that unified our home lab
Pulse is the tool that lit up r/selfhosted this month. It targets exactly the setup most home labs run (a Proxmox host or two, a Docker box, and a TrueNAS or Synology for storage) and puts all of that on one screen. VMs, containers, LXCs, pool health, and node load sit side by side without any manual dashboard building.
Setup is a single Docker Compose file. We point it at a Proxmox API token and a Docker socket, and within a minute we have live counts, per-VM resource graphs, and container status. On a three-node Proxmox cluster with about forty containers, the dashboard stayed responsive and idled around 90 MB of RAM.
Where it falls short: Pulse is young. Public status pages, historical retention beyond a few weeks, and alert rules are still light. It is a home-lab dashboard first, an alerting platform second.
Pricing: Free and open source (donations welcome).
vs Uptime Kuma: Kuma shows us that a URL is up. Pulse shows us that the VM behind the URL has 4 GB free and the ZFS pool is healthy. Different jobs.
Download: https://github.com/rcourtman/Pulse
Bottom line: If we run Proxmox plus Docker, install Pulse this weekend.
Beszel, the pretty Kuma with an agent
Beszel is what happens when someone loves Kuma’s clean interface but needs host metrics. It ships as two tiny Go binaries (a hub and an agent), no runtime dependencies, and the web UI is genuinely nice looking. Charts for CPU, memory, disk, network, and Docker container stats are all built in.
We ran the agent on six machines, a mix of x86 and ARM. Each agent used under 20 MB of RAM. Adding a system to the hub was a copy-paste key exchange, no fiddly config files.
Where it falls short: Beszel does not do HTTP endpoint monitoring the way Kuma does. It watches hosts and containers, not remote URLs. Notification integrations are still growing (Discord, Telegram, email, generic webhook, SMTP), but the templating is not as rich as Gatus.
Pricing: Free and open source.
vs Uptime Kuma: Kuma pings services from outside. Beszel reports what is happening inside the host. Many labs end up running both.
Download: https://beszel.dev
Bottom line: The prettiest self-hosted host monitor we tested this year.
Gatus, YAML checks and serious alert rules
Gatus flips the model. Instead of clicking through a UI to add monitors, we describe every endpoint in a YAML file, commit it to Git, and Gatus reloads on change. The condition language is expressive: response time, status code, JSON body assertions, TLS expiry, DNS, ICMP, TCP, and more.
The alerting is where Gatus pulls ahead. Slack, Teams, Discord, PagerDuty, Opsgenie, Gotify, ntfy, and Matrix are all first-class, and each endpoint can have its own alert thresholds and cooldowns. We pushed a mid-sized config with about seventy checks through it during testing and CPU stayed under two percent.
Where it falls short: The dashboard is minimal. If we want a themable public status page, Gatus is not the tool. It also stores history in a database that we should back up separately.
Pricing: Free and open source.
vs Uptime Kuma: Kuma is UI-first, Gatus is config-first. If our monitoring belongs in a Git repo, Gatus wins.
Download: https://gatus.io
Bottom line: For anyone who already runs infrastructure as code, this is the natural fit.
Statping-ng, a public status page done right
Statping-ng picked up where the original Statping went dormant. Its focus is the public-facing status page, the one we point customers, family, or teammates at when something is down. Themes are swappable, incidents can be posted from the admin panel, and the whole thing renders fast even on a small VPS.
We stood it up on a $5 droplet with about fifteen services and the memory footprint held around 60 MB. Notifications cover the usual chat platforms and email.
Where it falls short: The internal check engine is not as flexible as Gatus, and host metrics are outside its scope. Under the hood, releases have been steady but not frequent, which matters if we need to know a CVE is patched fast.
Pricing: Free and open source.
vs Uptime Kuma: Kuma’s status page is fine for a home lab. Statping-ng is the one to give paying users.
Download: https://github.com/statping-ng/statping-ng
Bottom line: The tool to reach for when the status page itself is the product.
Checkmk Raw, when the fleet gets serious
Checkmk Raw is the free edition of a full commercial monitoring platform. That heritage shows up everywhere: hundreds of built-in plugins, agent auto-discovery, distributed monitoring, event correlation, and a plugin marketplace with community and vendor-signed integrations. On paper it is the closest we get to enterprise monitoring without paying for it.
We ran the Docker image against a small mixed fleet (Linux, Windows, a network switch via SNMP, and a Kubernetes cluster) and Checkmk pulled in about 400 services automatically. Once we tuned the discovery, the noise dropped and the dashboards were usable.
Where it falls short: The learning curve is real. The UI carries a lot of legacy patterns, and Raw is missing the pretty operator dashboards, reporting, and role-based access control that the paid editions ship.
Pricing: Raw edition is free forever. Cloud and Enterprise editions start around $600 per year for small setups.
vs Uptime Kuma: Kuma is a screwdriver, Checkmk is a workshop.
Download: https://checkmk.com
Bottom line: Worth the ramp-up once we cross about fifty nodes.
Zabbix, enterprise depth at zero cost
Zabbix has been around long enough to have monitored our first server rack. It is fully free, including the enterprise features (distributed monitoring, HA proxies, encryption everywhere, granular RBAC), and paid plans buy support, not features. Any metric can trigger any action, and the trigger language is legitimately powerful.
We tested Zabbix 7 against a mixed fleet. The agent is mature and lightweight, autodiscovery worked out of the box for network devices, and templates for Docker, Kubernetes, PostgreSQL, Redis, and most databases are official.
Where it falls short: The default UI is dated compared to Beszel or Netdata. Setting up frontend dashboards requires effort, and many teams end up shipping Zabbix data to Grafana for the actual viewing experience.
Pricing: Free. Paid support tiers exist for teams that need SLAs.
vs Uptime Kuma: Kuma covers weekend home labs. Zabbix covers datacenters.
Download: https://zabbix.com
Bottom line: If a home lab has grown into a small business, Zabbix is the safe long-term bet.
Netdata, real-time metrics with a stunning default UI
Netdata’s pitch is per-second resolution on every metric, with dashboards that look great before we touch a single setting. The agent runs on the host, collects everything from CPU jitter to Postgres queries, and exposes a local web UI immediately after install. It is the fastest way to see, right now, why a machine feels slow.
The self-hosted parent-child topology lets us aggregate many agents to a central node without paying for Netdata Cloud. That said, Cloud is where multi-node views, saved dashboards, and mobile alerts live, and for small teams it is not expensive.
Where it falls short: Retention on the free self-hosted side is bounded by disk. Long-term storage means either shipping to Prometheus or upgrading to Cloud. Alerting exists but is per-agent, so tuning a large fleet is slower than Gatus or Zabbix.
Pricing: Fully free self-hosted. Netdata Cloud paid tiers start around $3 per node per month.
vs Uptime Kuma: Kuma tells us something is wrong. Netdata tells us which process on which core is doing it.
Download: https://netdata.cloud
Bottom line: The tool we open first when a machine is misbehaving right now.
How to choose
Pick Pulse if we run Proxmox and Docker and want one dashboard for VMs, containers, and pool health. It is the easiest way to consolidate a small lab, and setup takes an evening.
Pick Beszel if we love Kuma’s simplicity but need agent-based CPU, RAM, and disk graphs. It is the closest replacement in feel, with a nicer chart layer.
Pick Gatus for the tightest YAML-first alerting. If our infra is already in Git, adding a monitor should be a pull request, not a click.
Pick Statping-ng if the status page is the point. Customers, teammates, or family members see a clean incident timeline, not our internal dashboard.
Pick Checkmk Raw if we manage more than fifty nodes and want plugin coverage that scales without writing custom checks. Ramp-up is real, and it pays back once the fleet is large.
Pick Zabbix for enterprise depth without an invoice. It is the most feature-complete free option, and it has the longest track record on this list.
Pick Netdata for real-time troubleshooting and gorgeous default dashboards. It complements the others well, so many labs run it next to Gatus or Beszel.
Stay on Uptime Kuma if we have fewer than 30 checks and only need HTTP or ping monitoring. It is still the fastest path to a working status page, and switching costs are real. Only move when a specific limit (agent metrics, alert rules, node count, dashboard polish) is blocking the lab.
Frequently asked questions
What is the best free alternative to Uptime Kuma?
Pulse and Beszel are the two we recommend most often. Pulse wins for Proxmox and Docker home labs that want a single pane of glass. Beszel wins for anyone who wants Kuma’s simplicity plus real host metrics. Both are fully free and open source.
Does Uptime Kuma support agent-based monitoring?
No. Uptime Kuma checks services from the outside, using HTTP, ping, TCP port, DNS, and similar probes. There is no agent that runs on a target host to report CPU, memory, or disk. For that we need Beszel, Netdata, Checkmk, or Zabbix.
Can Uptime Kuma monitor Proxmox?
Only indirectly. We can point Kuma at the Proxmox web UI or API endpoints and confirm they respond, but Kuma cannot report per-node CPU load, VM count, storage usage, or ZFS pool health. Pulse is built for exactly that job.
Which self-hosted monitoring tool has the prettiest dashboard?
Beszel and Netdata are the two we point people to for looks. Beszel’s UI feels like a refined Kuma with charts. Netdata’s per-second animations are unmatched for demoing what a healthy server looks like. Pulse is close behind and improving fast.
Is Zabbix overkill for a home lab?
Usually, yes. Zabbix is designed for hundreds or thousands of hosts, and the setup effort reflects that. For a home lab under about twenty machines, Beszel, Pulse, or Netdata will give a better ratio of insight to time invested. Zabbix pays off when we cross into small-business territory.
