Telemetry dashboards expose the lifeblood of modern systems. Whether you monitor a microservice cluster, a smart home sensor network or a production line, knowing what a component is doing in real time saves time and money. This tutorial walks you through building a fully functional, beginner-friendly dashboard with nothing but open-source tools.
Choosing the right stack
At the heart of any telemetry set-up are two engines: a collection layer and a visualisation layer. Prometheus is the de-facto collection engine. It pulls metrics in the Prometheus exposition format from exposed HTTP endpoints. The default here is /metrics, and the style uses key-value pairs that can be scraped every few seconds. On the other hand, Grafana turns those raw timestamps into charts, tables or heatmaps. Together they form a lightweight, battle-tested pair. Both projects ship with Docker images, so you can reduce installation friction dramatically. For the demo we pull the official images and run them side by side on a single VPS or laptop.
First, pull the images:
docker pull prom/prometheus # optionally a pre-configured node exporter docker pull prom/node-exporter docker pull grafana/grafana
Next, create a simple Prometheus configuration file, prometheus.yml, that tells Prometheus to scrape the /metrics endpoint. A minimal file looks like this:
global: scrape_interval: 15s scrape_configs: - job_name: "node" static_configs: - targets: ["localhost:9100"]
Now launch the exporter on port 9100:
docker run -d --name node_exporter --publish 9100:9100 prom/node-exporter
Finally, start Prometheus, mounting the config:
docker run -d --name prometheus \ --publish 9090:9090 \ -v $(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml \ prom/prometheus
Prometheus will now hit localhost:9100/metrics every 15 seconds, storing the data in its time-series database. If you open http://localhost:9090 you’ll see the web UI where you can issue quick queries like node_cpu_seconds_total.
With the data source live, you’re ready for visualisation. While the next section focuses on Grafana, you can skip ahead if you already know how to set up a Grafana instance:
docker run -d --name grafana --publish 3000:3000 grafana/grafana
Grafana’s default credentials are admin/admin. Once logged in, add the Prometheus data source pointing at http://host.docker.internal:9090 (adjusting for your network).
From metrics to visualisation
With the data source attached, you can start creating panels. In Grafana, a dashboard is a collection of panels that query Prometheus and display the results. Begin by creating a new dashboard and adding a Graph panel. Hit the Query tab, select the Prometheus data source, and type a simple expression like rate(node_cpu_seconds_total[1m]). Grafana will auto-plot the CPU usage over time. Use the Legend option to name the series, e.g. 'CPU Usage', so the chart is self-explanatory.
Once the panel looks good, you can add additional panels: a Table showing the top memory-heavy processes, an Gauge for system load, or a Stat panel for the uptime. Graphical panels can have thresholds; for example, set a red alert alerting when CPU usage exceeds 80% for ten minutes. To create an alert, click Alert, configure a for duration, and write a query like avg(rate(node_cpu_seconds_total[5m])) > 0.8. Grafana will notify you via email or Slack if you set up those notification channels.
File-level configuration is also useful. Export the dashboard as JSON using Grafana’s ‘Save As…’, then you can version it in Git. When changes need to be rolled out to a fleet of servers, copy the JSON file into the Grafana provisioning directory or push it via the HTTP API.
From metric collection to a live visual feed, you now have a basic telemetry dashboard. Your next step could be to plug in custom exporters for your application, expose services behind a reverse proxy, or secure the endpoints behind TLS. The open-source ecosystem offers countless extensions, so experimentation is key.
