Beszel is the tool I would put beside Uptime Kuma in a small homelab, not because it does the same job, but because it answers the next question.

Uptime Kuma tells you whether a service is reachable. Beszel tells you how the machine and containers behind that service are behaving over time: CPU, memory, disk, network, Docker/Podman stats, sensors, SMART, ZFS, alerts, and agent-side network checks.

That makes it one of the cleaner “what is my server doing?” dashboards in the current monitoring pile.

Beszel = Go hub + PocketBase storage + React dashboard + lightweight agents

What is Beszel?

The repository I checked was:

Repository: https://github.com/henrygd/beszel
Checked commit: 13bdd05934a7363016aa9a92c0d5bef13c0e81a4
Commit date: 2026-10-09
Latest checked tag: v0.21.0
License: MIT
Container image tested: docker.io/henrygd/beszel:0.21.0
Backend: Go, PocketBase
Frontend: React, Vite, TypeScript, Recharts, Radix UI

Beszel has two moving parts:

Component What It Does
Hub Web UI, API, auth, storage, alerts, system management
Agent Runs on each monitored host and reports host/container metrics

The hub embeds the web UI and stores its data in a PocketBase data directory. The agent runs close to the machine being monitored, which is why Beszel can show host-level and container-level metrics without asking you to assemble a Prometheus stack.

Why It Is Interesting

Most homelab monitoring conversations eventually split into different questions:

Question Common Tool
Is the service reachable? Uptime Kuma, Kuvasz, Uptime Kotlin
What changed on the server? Beszel, Netdata, Glances
What is wrong with my containers? Maintenant, Dozzle, Portainer
What do users need to know? Statup, Uptime Kuma status pages
What does my public website expose? Web-Check, LinkChecker
Are my domains/DNS/certs healthy? Domain Locker

Beszel is focused on the second question.

It is not trying to be a full observability platform. It is trying to give you a useful server and container dashboard with less wiring.

What Beszel Monitors

From the README and source, Beszel can track:

  • CPU usage, load average, memory, swap, and ZFS ARC;
  • disk usage and disk I/O;
  • network throughput;
  • Docker/Podman container status, CPU, memory, and network usage;
  • temperature and fan sensors;
  • connected Wi-Fi signal strength where the agent platform supports it;
  • Nvidia, AMD, and Intel GPU metrics where supported;
  • battery charge;
  • SMART health, eMMC wear, and mdraid health;
  • ZFS pool and dataset health, usage, I/O, and scrub status;
  • agent-side network monitors for ICMP, TCP, HTTP, and DNS;
  • alerts through email and webhook-style notification services.

It also supports multi-user setups, OAuth/OIDC, API access, and automatic backups to disk or S3-compatible storage.

Self-Hosting Beszel with Docker

I updated the Home-Lab compose here:

Home-Lab Beszel compose

The hub is exposed on port 3813 because port 8090 is already in use on this machine:

services:
  beszel:
    image: docker.io/henrygd/beszel:${BESZEL_VERSION:-0.21.0}
    container_name: beszel
    restart: unless-stopped
    environment:
      APP_URL: ${BESZEL_APP_URL:-http://192.168.1.2:3813}
    ports:
      - ${BESZEL_BIND:-0.0.0.0}:${BESZEL_PORT:-3813}:8090
    volumes:
      - ./beszel_data:/beszel_data
    healthcheck:
      test: ["CMD", "/beszel", "health", "--url", "http://localhost:8090"]
      interval: 120s
      start_period: 10s
      timeout: 5s
      retries: 3
    networks:
      - beszel

networks:
  beszel:
    ipam:
      config:
        - subnet: ${BESZEL_SUBNET:-10.89.13.0/24}

Start it with:

cd /home/jalcocert/Desktop/Home-Lab/beszel
cp .env.sample .env
docker compose up -d

Then open:

http://192.168.1.2:3813

There is no admin/admin default login in the current setup. On a fresh beszel_data directory, create the first user in the web UI.

Adding the Agent

The agent needs values generated by the hub. That is why I kept it in a separate compose file instead of shipping a fake public key in the main compose.

After creating the first user:

  1. Open Beszel.
  2. Go to Systems.
  3. Add a system.
  4. Copy the generated HUB_URL, TOKEN, and KEY.
  5. Put them in .env.
  6. Start the agent compose:
docker compose -f docker-compose.yml -f agent.compose.yml up -d

The local agent uses network_mode: host and mounts /var/run/docker.sock:ro, so treat it as infrastructure-level access even though the socket is read-only.

Field Note: Local Test

I ran the hub locally with the Home-Lab compose.

The first attempt hit a Docker host issue:

all predefined address pools have been fully subnetted

That is the same network-pool exhaustion we saw in a few recent compose tests, so the reusable compose now defines an explicit subnet:

10.89.13.0/24

After that, the hub started cleanly:

curl -I http://127.0.0.1:3813
curl http://127.0.0.1:3813/api/health

Result:

HTTP/1.1 200 OK
{"message":"API is healthy.","code":200,"data":{}}

The container healthcheck also became healthy with output ok.

How Beszel Compares with the Monitoring Tools We Covered

Tool Best Fit Notes
Uptime Kuma Simple uptime checks, push monitors, notifications, status pages Keep it for “is it up?”
Kuvasz Config/API-oriented uptime monitoring Better when you want monitoring as code
Uptime Kotlin Broad protocol checks with PostgreSQL and workers Heavier, but checks more infrastructure protocols
Statup Status page, incidents, maintenance, announcements Better for human communication
Maintenant Docker/Kubernetes operations, logs, certs, updates, status pages Broader operations cockpit
Web-Check One-off website reconnaissance Not continuous server monitoring
Domain Locker Domain inventory, DNS, expiry, cert awareness Watches domain assets, not host resources
Prometheus + Grafana Deep metrics platform More flexible, much more setup
Netdata Deep per-host live telemetry Richer per-host detail, less calm fleet dashboard

My practical pairing would be:

Uptime Kuma or Kuvasz = public service availability
Beszel                = host/container resource behavior
Statup               = public/internal incident communication
Maintenant           = container/Kubernetes operations view

FAQ

Conclusion

Beszel is a good fit when you want useful server monitoring without building an observability stack.

I would not use it as the only monitoring tool for every scenario. I would pair it with Uptime Kuma or Kuvasz for external uptime checks, and use Statup when the goal is clean incident communication.

But for a homelab where the day-to-day question is “which host or container is eating resources?”, Beszel is one of the least cluttered answers.