Monitoring server infrastructure often means wrestling with a growing pile of components: Prometheus, node_exporter, cAdvisor, Grafana dashboards, each with their own configs, resource demands, and operational overhead. Beszel takes a different path — it wraps monitoring agents and a web dashboard into a single Go binary, built on PocketBase, aiming for simplicity and a lighter footprint without sacrificing core metrics and features.
how beszel consolidates server monitoring with a hub-agent architecture
Beszel is a lightweight server monitoring platform written in Go, designed around a hub-agent architecture. The central hub hosts the web dashboard and data storage, while lightweight agents run on the systems you want to monitor, collecting metrics and sending them back to the hub.
The hub is based on PocketBase, an embedded Go backend that provides a ready-to-use API and web UI. PocketBase handles user management, OAuth/OIDC authentication, data persistence, and serves the dashboard interface. This choice significantly reduces the development effort and complexity, allowing Beszel to ship as a single binary for the hub with built-in web UI and backend.
Agents deployed on monitored hosts gather a broad set of system metrics: CPU usage, memory consumption, disk space and I/O, network statistics, GPU utilization, and container metrics for Docker and Podman environments. These cover the typical monitoring needs of homelabs or small server fleets.
Metrics collected by agents are reported to the hub, which stores and visualizes them through the web interface. Beszel supports multi-user management with roles and OAuth/OIDC authentication, configurable alerts on metrics with flexible thresholds, and automatic backups of monitoring data to disk or S3-compatible storage.
This architecture contrasts with the more common Prometheus ecosystem, which runs multiple distinct services (Prometheus server, exporters, Grafana dashboards) separately. Beszel bundles the hub and agent into individual Go binaries, simplifying deployment and resource usage.
the tradeoffs in beszel’s design and its technical strengths
Beszel’s main strength lies in its consolidation of monitoring components into minimal binaries, reducing complexity and operational overhead. Using PocketBase as the backend brings a lot of functionality out of the box: user authentication, data persistence, and a web UI. This lets the Beszel maintainers focus on the monitoring-specific logic rather than reinventing common infrastructure.
Under the hood, the codebase is idiomatic Go, leveraging Go’s concurrency model to run metric collection routines efficiently. The agent covers a wide range of metrics, from system-level stats to container-specific insights, which is impressive for a lightweight monitoring agent.
The hub-agent pattern is straightforward: agents push metrics to the hub over HTTP APIs. This is simpler than the pull-based Prometheus model, which can be easier to reason about but may have scalability tradeoffs in larger deployments.
Alerting is built into the platform with configurable thresholds, allowing users to get notified when metrics deviate from expected ranges. This feature is often a separate component in larger stacks, so its integration here adds value.
The tradeoff is clear: Beszel opts for simplicity and a smaller footprint over the extensive customization and plugin ecosystems of Prometheus and Grafana. This means you might miss some advanced querying capabilities, complex dashboards, or integrations, but the core use case of system and container monitoring with alerting is well covered.
Beszel’s support for OAuth/OIDC and multi-user roles is notable for a lightweight tool, improving security and team collaboration.
explore the project
The Beszel repository is organized around two main components: the hub and the agent. The hub binary encapsulates the PocketBase backend and the web dashboard, while the agent binary runs on monitored hosts collecting system and container metrics.
Documentation and a quick start guide are available on the project’s website at beszel.dev, which is the best place to start if you want to deploy it.
The README provides an overview of features and architecture but does not include explicit installation commands or scripts. To get a feel for the code, begin by exploring the cmd/hub and cmd/agent directories which contain the respective entry points.
Configuration is primarily done through environment variables and JSON files, documented in the wiki and examples. The web dashboard exposes metrics visualization, user management, and alert configuration.
Since the project bundles the backend and UI in a single binary via PocketBase, there is no need to manage separate services for database, auth, and frontend, which simplifies setup.
verdict
Beszel is a solid option for users who want a lightweight, all-in-one monitoring platform without the complexity of assembling and maintaining a Prometheus+Grafana stack. Its single-binary hub and agent model reduce resource usage and operational overhead, making it especially attractive for homelabs or small server fleets.
The tradeoff is that it doesn’t offer the deep customization, plugin ecosystem, or advanced querying capabilities of more mature monitoring stacks. If your monitoring needs are straightforward and you value simplicity and ease of deployment, Beszel is worth considering.
For larger or more complex environments, or if you rely heavily on sophisticated dashboards and integrations, traditional stacks might still be the way to go.
Overall, the code quality is solid and the use of PocketBase as an embedded backend is a pragmatic choice that speeds up development and simplifies deployment. If you want to reduce monitoring infrastructure complexity and are comfortable with Go-based tooling, Beszel deserves a closer look.
→ GitHub Repo: henrygd/beszel ⭐ 21,606 · Go