Short answer: for 1-20 servers, deploy Beszel. Its agent runs on roughly 10-15MB of RAM against Netdata’s 200-500MB and a Grafana + Prometheus stack’s 500MB-1GB+, and it answers “is my server healthy” in five minutes with no query language. Add Uptime Kuma when you also need to know whether your services are reachable.

That is the whole verdict. The rest of this guide is the evidence: seven self-hosted server monitoring tools tested on RAM, setup time, and what each one actually watches, plus the supporting tools that round out a real stack.

How I compared these, and when. RAM figures come from each tool’s own documentation plus independent 2026 benchmarks. Every price, free-tier limit, and version number below was re-checked against the vendor’s own pricing page and the project’s GitHub releases on 6 August 2026. Where a tool’s marketing number and real-world measurements differ (Beszel’s “under 10MB” agent, for example), I give both.

Which server monitoring tool should you use in 2026?

For 1-20 servers, Beszel is the default: a ~10-15MB agent, five-minute setup, $3/mo self-hosted. Add Uptime Kuma for endpoint availability, Dozzle for Docker logs, Pulse for Proxmox VM detail, and Netdata or Grafana + Prometheus only when you need one-second resolution or PromQL.

The picks in one line each:

Most people running 1-20 servers should deploy Beszel and add a second tool only when they outgrow it.

Why self-host monitoring instead of paying Datadog or Grafana Cloud?

Hosted monitoring bills per host or per metric series, so cost scales with your fleet while a self-hosted pod does not. Datadog Infrastructure Pro starts at $15 per host per month billed annually ($18 on demand). A self-hosted monitoring pod is a flat $3/mo and watches as many servers as you point agents at.

The gap widens fast. Netdata Cloud’s Business plan is $4.50 per node per month billed annually, and Grafana Cloud Pro carries a $19/mo platform fee that includes 10,000 active metric series, then charges from $6.50 per additional 1,000 series (all three checked 6 August 2026). A single Docker host can generate 5,000+ series, so five hosts lands around $117/mo on Grafana Cloud Pro. The same five servers report into one $3/mo Beszel pod.

The other reason is privacy. Self-hosted means your CPU graphs, process lists, and logs never leave a machine you control instead of being ingested by a third-party SaaS. Datadog, New Relic, and Dynatrace are genuinely powerful for large estates, but for a homelab or a small VPS fleet they are expensive overkill. If you are new to running your own apps, open-source hosting and the self-hosted apps directory are good starting points.

What is Beszel and how much RAM does it use?

Beszel is an open-source (MIT) server monitoring tool shipped as a single Go binary: a hub with a web dashboard plus one agent per machine. The agent uses roughly 10-15MB of RAM at idle. It tracks CPU, memory, disk, network, temperature, GPU, and per-workload Docker stats, and installs in under five minutes with no config files.

Why it’s popular: Beszel markets the agent as “under 10MB,” and independent 2026 benchmarks measure it between about 12MB and 23MB depending on the box. Even at the high end that is a fraction of Netdata (200-500MB) or a full Grafana stack (500MB+). On a Raspberry Pi or a cheap VPS, that difference is the whole argument. v0.18.7 (April 2026) is still the current release as of 6 August 2026.

Setup time: Under 5 minutes. Deploy the hub, run the agent on each server with a single command, and monitoring starts immediately. No configuration files, no query languages, no dashboard building. Self-managed means a docker-compose hub plus an agent per server; on InstaPods it is a one-click $3/mo deploy.

What it monitors: CPU, memory, disk, network, temperature, GPU usage (NVIDIA via NVML/nvtop, with experimental Apple Silicon support added in v0.18.4), per-workload Docker stats, systemd service metrics, S.M.A.R.T. disk health, Linux mdraid health (v0.18.5), and detailed disk I/O (utilization, await, queue depth, added in v0.18.7). It stores historical data so you can look back days or weeks. Several gaps people still assume Beszel has are closed: systemd service monitoring, S.M.A.R.T. disk health with failure alerts, and disk I/O detail all shipped across the v0.17-v0.18 releases.

What it doesn’t do: No arbitrary application-defined custom metrics (the open feature request is henrygd/beszel #337, “Add ability to monitor custom values”; the older #731 was closed as a duplicate in January 2026 and neither has shipped as of v0.18.7). No PromQL, no log aggregation, no AI anomaly detection. The dashboard layout is fixed, so you cannot build custom charts. For deeper disk health than Beszel’s S.M.A.R.T. page, NAS and large-array owners can add Scrutiny (MIT, ~100-200MB with its InfluxDB backend) for historical SMART trends and Backblaze failure-rate context.

Best for: Homelabs, small VPS fleets, Docker-heavy setups, and anyone who wants server monitoring without the complexity. Outgrow it when you need application metrics, PromQL, or log search. Running Proxmox? See Beszel on Proxmox for what an agent inside an LXC guest actually reports. You can deploy Beszel on InstaPods in one click for $3/mo.

Is Netdata worth 200-500MB of RAM?

Only if you need what that RAM buys: 2,000+ metrics at one-second resolution with AI-powered anomaly detection. Netdata (v2.10.4, July 2026) is the depth-first opposite of Beszel. For a homelab asking “is my CPU OK,” it is 20-50x the footprint for information you will not read.

The pricing, checked 6 August 2026: Netdata Cloud’s free Community tier covers a maximum of 5 active connected nodes. A Homelab plan is $90/year for unlimited nodes, and the Business plan is $4.50 per node per month billed annually. The agent itself is GPL-3.0 and free to self-host.

Setup time: 10-15 minutes for the agent install. Cloud signup adds another 5-10 minutes. Customizing alerts and dashboards means editing YAML configuration files.

The overwhelm problem: Netdata shows 2,000+ charts by default. For most self-hosters who want to know “is my CPU OK and is Docker behaving,” this is information overload. You scroll past charts you will never look at to find the three metrics you care about.

Best for: Teams that need deep observability, one-second resolution, or AI anomaly detection across complex infrastructure. If you run a production SaaS on 50+ nodes, Netdata’s depth is genuinely useful. Compare Beszel vs Netdata for the full lightweight-vs-deep breakdown.

What is the best self-hosted Docker log viewer?

Dozzle. It is a ~10MB MIT-licensed web UI that streams live logs from every Docker workload on a host, with regex search, JSON auto-detection, multi-host viewing, and SQL queries over logs via DuckDB. It is a log viewer only: no CPU, memory, or disk metrics, and no resource alerts.

Dozzle reached v10.0 in February 2026, which added webhook alerts and a redesigned notifications page, and it is on v10.6.14 as of 30 July 2026. It now supports Kubernetes alongside Docker and Swarm.

What it doesn’t do: No CPU, memory, or disk metrics. No historical metric graphs. No threshold alerts for resource usage. If a workload silently eats all available RAM without logging about it, Dozzle will not catch it.

Why it pairs with Beszel: This is the most common self-hosted monitoring stack in 2026. Beszel for metrics (“something is using too much CPU”) and Dozzle for logs (“let me read the error to find out why”). Both are lightweight, both take minutes to set up, and together they replace what used to require Grafana + Prometheus + Loki. Compare Beszel vs Dozzle for the metrics-vs-logs split.

Best for: Anyone running Docker who needs to check logs without SSH-ing in to run docker logs.

What are the best Docker monitoring tools?

Three tools cover Docker hosts: Beszel for per-workload CPU, memory, and network stats inside its normal dashboard (~10-15MB, zero config), Dozzle for live logs and search (~10MB), and cAdvisor when you specifically need raw Prometheus-scrapeable metrics. Beszel plus Dozzle covers most setups for about 20-25MB of RAM total.

cAdvisor is the third option and the most misunderstood. It is Google’s open-source metrics daemon (Apache-2.0, roughly 50-150MB resident). It reads each workload’s Linux cgroup data and exposes raw, Prometheus-scrapeable CPU, memory, network, and filesystem time-series. That is the one job none of the lightweight tools do. But it ships no dashboard of its own, so you still need Prometheus to store the data and Grafana to see it. Pair it with node_exporter (the host-metrics equivalent) and you have rebuilt the exact four-component stack Beszel removes. cAdvisor is the right answer only when you want queryable per-workload metrics inside an existing Prometheus setup.

One 2026 note: enterprise Docker monitoring is shifting toward eBPF and kernel-level tools (Datadog, Sysdig, Dynatrace) for zero-instrumentation visibility. Powerful, and far past what a homelab or small VPS fleet needs.

Do you still need Grafana and Prometheus in 2026?

Only for custom dashboards, PromQL, multi-datasource views, or alerts routed to PagerDuty. A working stack is four components (Prometheus, node_exporter, cAdvisor, Grafana), 500MB-1GB+ of RAM, and 2-8 hours to a useful dashboard. For “is my server healthy,” that is a lot of machinery to answer one question.

The cost in practice. Modern setups increasingly use a single collector (Grafana Alloy) instead of node_exporter + cAdvisor + Promtail separately. It simplifies collection but still needs Prometheus + Grafana to be useful, and the RAM floor barely moves.

Grafana Cloud, checked 6 August 2026: the free tier is limited to 10k active series per month with 14 days retention. Pro adds a $19/mo platform fee that includes the same 10k series, then charges from $6.50 per additional 1,000 series. A single Docker host can generate 5,000+ series, so five hosts is roughly 25,000 series, or about $117/mo.

Netdata vs Prometheus: these come up together a lot and sit at opposite ends. Netdata is a batteries-included, local-first agent that shows 1-second metrics immediately with no query language. Prometheus is pull-based, scrapes on an interval (commonly 15 seconds), stores the result, and exposes PromQL, but it needs Grafana to visualize anything. In one 2026 benchmark, Netdata used about 35% less CPU than Prometheus (4.93 vs 7.56 cores), and a 15-second scrape can miss short spikes Netdata catches. Choose Netdata for instant visibility, Prometheus for long-term queryable observability.

Best for: Production infrastructure teams, SREs, and anyone who considers PromQL a feature rather than a barrier. Compare Beszel vs Prometheus + Grafana for the self-hosted-vs-stack breakdown.

What is the best monitoring tool for Proxmox?

Pulse. It auto-discovers every node, VM, and LXC guest through the Proxmox API and pushes updates over WebSockets, which is the per-guest visibility Beszel does not do. The core is free and open source (MIT, v6.1.2 as of July 2026). Use Pulse for Proxmox and Beszel for your non-Proxmox boxes.

Pricing, checked 6 August 2026: the self-hosted Community tier is free with no account required. A Relay tier is $39/year. MSP plans start at $149/mo (or $1,490/yr) for MSP Starter. A Pro tier exists with compliance and collaboration features, but its price is not published on the pricing page, so ask rather than trusting a figure quoted elsewhere.

The scope: Pulse started Proxmox-first but as of 2026 also monitors Docker and Kubernetes, plus Proxmox Backup Server and Mail Gateway. Where it still wins is per-node, per-VM, and per-LXC detail via the Proxmox API.

Beszel and LXC: a common point of confusion. Beszel can run on a Proxmox host or inside an LXC guest and report that machine’s CPU, memory, disk, and Docker stats, but it does not enumerate your VMs and guests through the API the way Pulse does, and an agent inside an LXC tends to report host-level stats unless you use the binary install. Beszel on Proxmox walks through exactly what you see either way. On a pure Docker VPS or Raspberry Pi, Beszel is still the lighter pick.

Best for: Proxmox environments needing deeper VM and LXC visibility than Beszel or Netdata provide. Compare Beszel vs Pulse for the full split.

When should you use Glances instead of a web dashboard?

For ad-hoc SSH debugging, not always-on monitoring. Glances (LGPL-3.0, Python) shows per-process CPU and memory sorted live in a terminal, plus hardware sensors like temperature, fan speed, and voltage that Beszel and Dozzle do not read. It costs 50-100MB of RAM, roughly 5x Beszel, and has no multi-server dashboard.

Glances has a web UI mode (glances -w), but it is basic, and there is no built-in historical data without an InfluxDB export. For a pure interactive terminal view, btop is the modern htop (a few MB, run on demand), but unlike Glances it has no web UI, REST API, or remote multi-server mode, which is why Glances earns the always-available slot here.

Best for: SSH-heavy workflows where you want an htop replacement with more data. Pairs well with Beszel handling always-on monitoring while Glances handles ad-hoc debugging. Compare Beszel vs Glances for web dashboard vs terminal.

Do you need Uptime Kuma if you already run Beszel?

Yes, because they do not overlap. Beszel watches resources from inside the server and answers “is my server healthy.” Uptime Kuma checks HTTP, TCP, DNS, ping, SSL, gRPC, and MQTT from outside and answers “is my service reachable.” A server at 10% CPU tells you nothing if your site is returning 502s behind a broken proxy.

Uptime Kuma is MIT-licensed and on v2.5.0 as of 1 August 2026. The feature set: 90+ notification channels, built-in status pages, maintenance windows, SSL certificate expiry monitoring, and check intervals down to 20 seconds, all for ~30-50MB of RAM (closer to 60-80MB once you run 20-30 monitors).

Beszel vs Uptime Kuma compared

BeszelUptime Kuma
Answers”Is my server healthy?""Is my service reachable?”
MonitorsCPU, memory, disk, network, Docker statsHTTP, TCP, DNS, ping, SSL, gRPC, MQTT
PerspectiveInternal resource metricsExternal checks
Status pagesNoYes (built-in, customizable)
AlertingThreshold alerts (email, webhook)90+ notification channels
RAM~10-15MB per agent~30-50MB (60-80MB at 20-30 monitors)
Best forCatching overload before a crashKnowing the instant a service goes down

Run both. Beszel tells you a server is about to fall over, Uptime Kuma tells you the moment something actually went down. Combined they sit around 40-65MB of RAM and cost $6/mo on InstaPods ($3/mo each). For the full breakdown, see Beszel vs Uptime Kuma.

Gatus: the config-as-code alternative

If you prefer version-controlled, GitOps-style monitoring over a clicky UI, Gatus is the lightweight counterpart to Uptime Kuma. Where Uptime Kuma stores its config in SQLite, Gatus defines every health check (HTTP, TCP, ICMP, DNS, SSH, TLS) in a single declarative YAML file you keep in Git, then renders a status page from it. It is a single Go binary (Apache-2.0, ~10-40MB, lighter than Uptime Kuma’s Node app). Choose Gatus when you want reproducible config in version control; choose Uptime Kuma when you want a point-and-click UI, 90+ notification integrations, and per-monitor history without editing YAML. The full head-to-head is in Gatus vs Uptime Kuma, including the condition language and the in-memory storage default that quietly throws away your history on restart.

Best for: Anyone who needs to know when their website, API, or service goes down. Deploy Uptime Kuma on InstaPods for $3/mo.

What monitoring stack should you actually run?

Beszel + Dozzle covers about 90% of homelab and small-fleet needs for under 25MB of RAM and $3/mo. Add Uptime Kuma ($6/mo total, under 80MB) when you need availability alerts and a status page. Add Pulse for Proxmox. Only reach for Prometheus + Grafana (500MB+) when you need PromQL or custom dashboards.

The Lightweight Stack (under 25MB RAM): Beszel + Dozzle. Server metrics + Docker logs. Total cost: $3/mo on InstaPods.

The Complete Stack (under 80MB RAM): Beszel + Dozzle + Uptime Kuma. Adds endpoint availability and status pages, so you know when something breaks AND why. Total cost: $6/mo on InstaPods.

The Proxmox Stack: Beszel + Pulse. Beszel for Docker hosts and general servers, Pulse for VM-level and LXC visibility.

The Enterprise Stack (500MB+ RAM): Prometheus + Grafana for custom metrics and PromQL. Only if you need custom dashboards, multi-datasource views, or complex alerting rules.

Two things round out any of these. For cron and backup jobs, a dead-man’s-switch like the self-hosted Healthchecks.io covers the “did my nightly backup actually run?” gap that metrics and uptime tools both miss: jobs ping a URL on success, and you get alerted when a ping goes missing. And to actually get pinged, route every tool’s alerts through a lightweight notification server like ntfy (~20MB, HTTP-native, with iOS and UnifiedPush apps) or Gotify, instead of wiring each tool to email separately.

How do you pick the right tool for your setup?

Start with Beszel, then add one tool per problem you actually hit. The decision tree:

How much RAM does each monitoring tool use?

Beszel’s agent is the lightest always-on option at ~10-15MB, followed by Dozzle (~10MB), Gatus (~10-40MB), Uptime Kuma (30-50MB), Glances and Pulse (~50MB), cAdvisor (50-150MB), Netdata (200-500MB), a Grafana + Prometheus stack (500MB-1GB+), and Checkmk’s server (~1-2GB).

Server monitoring tools compared: RAM, resolution, setup time, license, and best use case. Versions and prices checked 6 August 2026.
ToolRAMResolutionSetupLicenseBest for
Beszel~10-15MB agent1 minute5 minMITLightweight metrics for 1-20 servers
Netdata200-500MB1 second15 minGPL-3.0+Deep, one-second observability
Dozzle~10MBReal-time (logs)2 minMITReading Docker logs
cAdvisor~50-150MBScrape interval10 minApache-2.0Queryable Docker metrics in Prometheus
Glances50-100MBReal-time2 minLGPL-3.0Terminal / ad-hoc process debugging
Uptime Kuma30-50MB20s-5min5 minMITEndpoint uptime + status pages
Gatus~10-40MBConfig-defined5 min (YAML)Apache-2.0Config-as-code status pages
Grafana + Prometheus500MB-1GB+15 seconds2-8 hoursAGPL/ApacheCustom dashboards + PromQL
Proxmox Pulse~50MBReal-time (WebSocket)5 minMITPer-VM/LXC Proxmox visibility
Checkmk (Raw)~1-2GB (server)Agent-based30+ minGPLv2Large mixed fleets you outgrow lightweight tools for

Every tool above is self-hosted and open source, so your monitoring data stays on a machine you control (Netdata Cloud and Grafana Cloud send data to a SaaS only in their hosted modes). Checkmk anchors the heavy end: capable, with auto-discovery and a big plugin catalog, but its server wants ~1-2GB of RAM, well past this guide’s 1-20-server audience (Beszel vs Checkmk breaks down where the line is). Zabbix sits in the same enterprise tier with SNMP, network discovery, and distributed proxies, and runs as a full server + database + web frontend, so Beszel vs Zabbix is the comparison to read if you only need server and Docker metrics.

The monitoring landscape has shifted. You do not need a four-component stack to answer “is my server healthy.” Start lightweight, add complexity only when you need it.

Deploy Beszel on InstaPods - one click, $3/mo, monitoring in 5 minutes.

FAQ

Beszel vs Uptime Kuma: which one do I actually need?

They measure different things, so for most people the answer is both. Beszel tracks resource health (CPU, memory, disk, Docker stats) and answers “is my server healthy,” while Uptime Kuma tracks availability (HTTP, TCP, ping, SSL) and answers “is my service reachable.” A server at 10% CPU is useless information if your site is returning 502s, which is exactly the gap Uptime Kuma fills. They do not overlap, so running both at roughly 40-65MB combined is the standard small-fleet setup.

Can I run Beszel and Uptime Kuma together?

Yes, and you should. They monitor different layers and do not conflict. Beszel handles internal resource metrics and Uptime Kuma handles external availability and status pages. On InstaPods you can deploy each as a one-click app for $3/mo, so the full metrics-plus-uptime stack runs at $6/mo.

What is the most lightweight self-hosted server monitoring tool?

Beszel is the lightest always-on option, with an agent measured at roughly 10-15MB of RAM at idle. Dozzle (logs) and Gatus (availability) are similarly light single Go binaries, while Netdata uses 200-500MB and a full Grafana + Prometheus stack uses 500MB-1GB+. For a pure on-demand terminal view, btop uses only a few MB but is not a remote or multi-server monitor.

Does Beszel support custom metrics?

Not arbitrary application-defined custom metrics as of v0.18.7, still the current release on 6 August 2026. The open feature request is henrygd/beszel #337 (“Add ability to monitor custom values”); an earlier duplicate, #731, was closed in January 2026. There is no PromQL-style query language either. Beszel has, however, added systemd service monitoring, S.M.A.R.T. disk health, mdraid health, and detailed disk I/O metrics across the v0.17-v0.18 releases. If you need fully custom application metrics, pair Beszel with Prometheus and Grafana.

Can Beszel monitor Proxmox or LXC guests?

Partly. Beszel can run on a Proxmox host or inside an LXC guest and report that machine’s CPU, memory, disk, and Docker stats. It does not enumerate Proxmox VMs and LXC guests through the Proxmox API the way Pulse does, and an agent inside an LXC tends to show host-level stats unless you use the binary install. For per-VM and per-LXC Proxmox visibility, use Pulse, and use Beszel for your non-Proxmox boxes.

How is Netdata different from Prometheus?

Netdata is a batteries-included, local-first agent that shows 1-second-resolution metrics immediately with no query language to learn. Prometheus is a pull-based system that scrapes metrics on an interval (commonly 15 seconds), stores them, and exposes the PromQL query language, but it needs Grafana to visualize anything. In one 2026 benchmark, Netdata used about 35% less CPU than Prometheus, and a 15-second scrape interval can miss short spikes that Netdata catches. Choose Netdata for instant visibility, Prometheus for long-term, queryable, customizable observability.

What is cAdvisor and do I need it?

cAdvisor is Google’s open-source metrics daemon that reads each Docker workload’s cgroup data and exposes raw, Prometheus-scrapeable CPU, memory, network, and filesystem metrics. It has no dashboard of its own, so you only need it if you want queryable time-series inside an existing Prometheus and Grafana setup. For a simple “how are my Docker workloads doing” view, Beszel’s built-in stats are far less work.

How much does it cost to self-host server monitoring?

The software is free and open source for every tool in this guide. The only cost is the server it runs on. On InstaPods a Beszel pod is $3/mo, and the full Beszel + Dozzle + Uptime Kuma stack is about $6/mo. Hosted alternatives bill per host or per series: Datadog Infrastructure Pro from $15 per host per month billed annually ($18 on demand), Netdata Cloud Business at $4.50 per node per month, and Grafana Cloud Pro at a $19/mo platform fee plus $6.50 per additional 1,000 metric series beyond the included 10k (all checked 6 August 2026).

Related reading: