Homelab Monitoring Dashboard Guide

What Is a Homelab Health Dashboard and How Does Grafana Visualize It?

Grafana OSS visualizes homelab health dashboards by aggregating metrics, logs, and alerts from self-hosted servers. Grafana does not collect anything itself. It reads from data sources: Prometheus and InfluxDB for metrics, Loki for logs. A typical homelab stack is Telegraf or Node Exporter on each machine, Prometheus or InfluxDB to store the numbers, and Grafana on top to draw them.

Core Components of Grafana Dashboards

Grafana dashboards are made of panels. The ones you need for server health are time series graphs (CPU, memory, network over time), stat and gauge panels (current disk usage, uptime), and tables (which service is down). Grafana has hundreds of plugins for more data sources and panel types. Grafana OSS is licensed under AGPLv3.

To build a first dashboard with Prometheus and Node Exporter:

1. Install Node Exporter on each machine you want to watch. It listens on port 9100 and serves metrics at /metrics.
2. Add the machines as scrape targets in prometheus.yml (shown in the Prometheus section below).
3. In Grafana, open Connections, then Add new connection, search for Prometheus, and add it with the server URL, for example http://localhost:9090. Click Save & test. If Grafana and Prometheus run in separate containers, localhost points at the Grafana container, so use the Prometheus container's hostname instead.
4. Open Dashboards, choose New, then Import dashboard, enter ID 1860 (the community dashboard "Node Exporter Full") and click Load. Pick your Prometheus data source and click Import.

That gives you CPU, memory, disk and network panels for every machine without drawing a single panel by hand. Add your own panels later for the things only you care about.

Benefits for Self-Hosted Homelabs

Self-hosted Grafana, Prometheus and Telegraf cost nothing but the hardware they run on. If you would rather not run the storage yourself, Grafana Cloud has a free tier (see the limits below).

Thresholds make a dashboard useful at a glance. In a time series or stat panel you can set a threshold, for example CPU above a value you choose, and Grafana colors the panel red when the value crosses it. Pair it with an alert rule so you are told without having to look.

How Does Telegraf Collect Metrics for Homelab Server Monitoring?

Telegraf is a metrics agent that collects system metrics every 10 seconds by default and writes them to InfluxDB, Prometheus or another output. It has over 300 plugins in total (inputs, outputs, processors and aggregators), so one small agent can cover CPU, memory, disk, network and many databases and services. It is MIT licensed.

Configuring Telegraf Inputs for Homelabs

For a basic homelab server you need only a few inputs: cpu, mem, disk, diskio, net and system (load average and uptime). The agent collects them every 10 seconds unless you change interval in the [agent] section of telegraf.conf.

[agent]
  interval = "10s"

[[inputs.cpu]]
[[inputs.mem]]
[[inputs.disk]]
[[inputs.net]]
[[inputs.system]]

Telegraf also has inputs for services running in the lab, such as MySQL (port 3306) and Docker.

Output Integration with Dashboards

Grafana reads from a data source, not from Telegraf directly, so Telegraf needs an output that Grafana's data source can query. There are two common routes:

• To InfluxDB: use the influxdb_v2 output (InfluxDB listens on port 8086), then add InfluxDB as a data source in Grafana.
• To Prometheus: use the prometheus_client output, which exposes the metrics at http://<host>:9273/metrics. Add that address as a scrape target in Prometheus, then add Prometheus as the Grafana data source.

Telegraf also has a file output that writes metrics to a local file, which is handy for checking what an input produces before you wire up a database.

What Prometheus Scrape Interval Optimizes Homelab Monitoring?

Prometheus scrapes every 1 minute by default; for a homelab, 15 seconds is a good setting. The global scrape_interval defaults to 1m (with a 10s scrape timeout). Fifteen seconds is the value used in Prometheus's own example configuration. It gives you finer graphs and faster alerts, and a handful of machines produces little load. If you only need trends, leave the default and save disk space. Prometheus itself listens on port 9090 and is Apache 2.0 licensed.

Setting Up Prometheus Targets

Each machine you monitor runs an exporter, and Prometheus pulls from the exporter's own port, not from port 9090. Node Exporter listens on port 9100. A minimal prometheus.yml looks like this (replace the addresses with your own machines):

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: node
    static_configs:
      - targets: ['192.168.1.10:9100', '192.168.1.11:9100']

Start Prometheus with ./prometheus --config.file=./prometheus.yml, open http://localhost:9090/targets, and check that each target shows as up.

Alerting with Alertmanager

Two programs share the job. Prometheus evaluates alert rules against the data it has collected. When a rule fires, Prometheus sends the alert to Alertmanager, which groups related alerts, removes duplicates and routes them to a receiver: email, Slack, PagerDuty, Opsgenie, Telegram, a generic webhook and others.

A rule for a machine whose CPU has been busy for ten minutes (the 90% and ten minutes are example values, set your own):

groups:
  - name: homelab
    rules:
      - alert: HighCpu
        expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 90
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "CPU above 90% on {{ $labels.instance }}"

Alertmanager then needs a route and a receiver, for example email:

route:
  receiver: homelab-email
receivers:
  - name: homelab-email
    email_configs:
      - to: you@example.com
        send_resolved: true

You also need the smtp_smarthost and sender settings under global: in alertmanager.yml. Check the file with amtool check-config alertmanager.yml and send a test alert before you rely on it.

How Does InfluxDB Store Data for Homelab Health Dashboards?

InfluxDB OSS 2.x stores time-series data over HTTP on port 8086 and queries it with Flux or InfluxQL. InfluxDB 3 Core, the current open-source edition, uses SQL and InfluxQL. InfluxDB integrates with Grafana for performance and uptime visualization. InfluxDB Cloud Serverless has a free plan that is rate-limited rather than capped in gigabytes: writes of 5MB per 5 minutes, queries of 300MB per 5 minutes, 30-day retention and 2 buckets.

InfluxDB OSS vs Cloud for Homelabs

InfluxDB 3 Core runs on your own hardware under the MIT and Apache 2 licenses and stores the data Telegraf sends it. Cloud Serverless is the hosted option. Past the free plan it is usage-based: $0.0025 per MB written, $0.012 per 100 queries and $0.002 per GB-hour of storage, with no minimum.

For most homelabs the free plan is enough to try the setup, and OSS is the better long-term choice because you keep the data and pay no usage fees.

Querying Metrics with Flux

A Flux query starts from a bucket, limits the time range, filters to the measurement and field you want, and optionally averages over windows. This one returns the average CPU usage per 5-minute window for the last 24 hours (usage_user is the field Telegraf's cpu input writes):

from(bucket: "homelab")
  |> range(start: -24h)
  |> filter(fn: (r) => r._measurement == "cpu" and r._field == "usage_user")
  |> aggregateWindow(every: 5m, fn: mean)

Paste the same query into a Grafana panel that uses the InfluxDB data source (set to the Flux query language) to draw it. Telegraf writes data to InfluxDB using the line protocol over HTTP.

What Free Tier Limits Apply to Grafana Cloud for Homelab Monitoring?

Grafana Cloud free tier provides 10,000 Prometheus series, 50GB Loki logs, and 50GB Tempo traces monthly with 14-day retention for 3 users. The tier supports alerting through email, Slack webhooks and PagerDuty. It suits a small homelab dashboard with no upfront cost, as long as you stay within the 10,000 active series.

Metrics and Logs Ingestion Caps

Free tier ingests 10,000 active series from Prometheus. Loki handles 50GB logs per month with 14-day retention. Tempo traces: 50GB ingested per month.

Each machine running Node Exporter produces many series, because most metrics repeat per CPU core, disk, filesystem and network interface, so check your active series count in Grafana Cloud before adding more machines.

Upgrading to Pro for Larger Homelabs

Pro costs from $19 per month as a platform fee plus usage. It includes the same 10k series, 50GB of logs and 3 users as Free, then charges per use beyond that (extra users start at $8 each). Metrics are kept for 13 months instead of 14 days. Most homelabs never need it. Check grafana.com/pricing for current rates.

How Does Loki Aggregate Logs in Self-Hosted Homelab Setups?

Loki stores logs that an agent ships to it, and you search them in Grafana with LogQL. Loki is AGPLv3 licensed and listens on port 3100. Putting logs next to metrics in Grafana lets you click from a spike on a graph to the log lines from the same minute. The agent that ships the logs used to be Promtail, but Promtail reached end of life on March 2, 2026. Use Grafana Alloy instead.

Shipping Logs with Grafana Alloy

Grafana Alloy is the replacement for Promtail, and all new log-collection development happens there. This Alloy configuration tails log files under /var/log and pushes them to Loki's push endpoint (/loki/api/v1/push):

local.file_match "logs" {
  path_targets = [{__path__ = "/var/log/*.log"}]
}

loki.source.file "varlog" {
  targets    = local.file_match.logs.targets
  forward_to = [loki.write.local.receiver]
}

loki.write "local" {
  endpoint {
    url = "http://localhost:3100/loki/api/v1/push"
  }
}

If you already have a Promtail setup, Grafana provides a command that converts a Promtail config to Alloy format.

Querying Logs in Grafana

LogQL queries filter log lines for errors. In Grafana, a query such as {filename=~"/var/log/.*"} |= "error" shows only lines containing the word error. Loki complements metrics for full homelab health views.

The free Grafana Cloud tier includes 50GB of logs with 14-day retention.

What Visual Sentinel Features Enhance Homelab Monitoring Dashboards?

Grafana and Prometheus tell you how your machines are doing. They do not tell you what a visitor sees. Visual Sentinel is a separate hosted service that checks the website itself: visual changes, SSL, DNS, uptime and performance monitoring. Content checks start on Starter. It runs alongside Grafana, not inside it.

Adding Visual Checks Alongside Grafana

Homelab users add Visual Monitoring to compare scheduled screenshots of a public web app and catch layout changes that server metrics miss. Uptime checks run every 5 minutes on Solo and Starter and every minute on Business and Agency, and SSL monitoring sends expiry reminders 13, 3 and 1 days before by default (20 and 6 days optional). Add the homelab's public hostname and you are covered from the outside.

Free Tools for Quick Homelab Scans

The SSL Checker, DNS Checker and Speed Test are free tools that run on demand without an account. Uptime Monitoring is the paid, scheduled version: it checks from Europe and the US and alerts through the channels you set up.

How to Compare Visual Sentinel with UptimeRobot for Homelab Use?

Visual Sentinel offers visual detection, SSL and DNS checks on every plan, and content detection from Starter. UptimeRobot's free plan covers up to 50 simple uptime checks at 5-minute intervals. Visual Sentinel is paid (no free plan) and adds screenshot and text checks on top of uptime.

Key Monitoring Layers

Visual Sentinel compares website screenshots for appearance changes. Content monitoring checks expected text; Starter and higher also support must-contain and must-not-contain rules.

Scheduled DNS results sit well next to a read on DNS propagation.

Pricing and Ease for Self-Hosted

Visual Sentinel plans are Solo, Starter, Business and Agency, capped at 10, 15, 60 and 300 monitors, and start at $15/month for 10 monitors. UptimeRobot's Solo plan starts at $13/month ($12 billed annually) for 10 monitors with 60-second checks.

If you are starting from nothing, build in this order:

1. Install Node Exporter on each machine and Prometheus on one of them, then confirm the targets show as up.
2. Add Grafana, connect Prometheus and import dashboard 1860.
3. Add Alertmanager with one alert rule you care about (disk almost full is a good first one) and send yourself a test alert.
4. Add Loki and Alloy when you want logs next to the graphs.
5. Add Visual Monitoring from Visual Sentinel for the public side: the first check of your site needs no card, and the 10-day free trial needs no card with a work email.

Run a website of your own? Read about keeping watch over your own website, so an alert tells you when something on it breaks.