Grafana vs Prometheus: What Each Actually Does (And Do You Need Both?)

Search “grafana vs prometheus” and the top results all open with the same correct sentence — they’re complementary, not competitors — and then spend two thousand words on Kubernetes federation and enterprise observability platforms. Correct framing, wrong audience. If you’re a self-hoster deciding what to actually deploy on your Docker host this weekend, the questions that matter are different: what does each piece really do, which alerting system should you use (there are two, and that’s the real “vs”), and what does the whole stack cost in RAM? Those are the questions this guide answers, with numbers from the stack we actually run.

The one-paragraph version: Prometheus collects and stores metrics — it scrapes exporters on your machines every 15 seconds into its own time-series database and evaluates alert rules. Grafana visualizes them — it queries Prometheus (or ~50 other data sources) and turns the numbers into dashboards. You deploy both, they fit in well under a gigabyte of RAM, and the only genuine either/or decision inside the stack is Alertmanager vs Grafana Alerting. Everything below unpacks that.

What Prometheus actually does

Prometheus (currently 3.x LTS, Apache 2.0, an independent CNCF project) is the data layer:

• Pull-based scraping. Prometheus polls HTTP endpoints called exporters on an interval (15s is the common default). Nothing pushes to it; it fetches.
• A built-in time-series database (TSDB). Metrics land on local disk with configurable retention (15 days by default). Per the official storage docs, Prometheus “stores an average of only 1-2 bytes per sample” — the documented capacity formula is retention_seconds × samples_per_second × bytes_per_sample. In practice, our 5-node stack at 15-day retention sits in the low single-digit gigabytes.
• PromQL. The query language for rates, aggregations, and alert conditions — the same expressions power both dashboards and alerts.
• The exporter ecosystem. This is why Prometheus owns homelab monitoring: node_exporter for Linux hosts (~15MB RAM each), windows_exporter, pve-exporter for Proxmox, cAdvisor for Docker containers, blackbox_exporter for HTTP/ping probes.

What Prometheus deliberately does not do: dashboards. Its built-in expression browser is a debugging tool, not a UI you’d live in. And it doesn’t handle logs — metrics only.

What Grafana actually does

Grafana (currently 13.x; OSS core AGPLv3 since v8.0, plugins Apache 2.0) is the presentation layer:

• Dashboards. Drag-and-drop panels — time series, gauges, heatmaps, stat panels, tables. The community dashboard library means a full Linux-host dashboard is an import-by-ID away.
• Data-source agnostic. Prometheus is one of dozens of native sources alongside Loki, InfluxDB, MySQL, Elasticsearch, CloudWatch, and more. Grafana is the one pane of glass over all of them.
• Grafana Alerting. Since Grafana 9, a unified alerting system that creates alert rules against any data source through the GUI, with notification “contact points” configured in the UI.

What Grafana cannot do: collect or store anything. No scraping, no database. Without a backend it’s an empty shell — which is precisely why the “vs” framing fails.

The real comparison: Prometheus Alertmanager vs Grafana Alerting

Here’s the genuine either/or decision inside the stack, and the one the usual comparisons skip entirely. Both tools can fire alerts; they do it very differently.

Prometheus Alertmanager is a separate small binary. Prometheus evaluates alert rules you write in YAML (PromQL expressions with thresholds and durations) and fires them to Alertmanager, which handles deduplication, grouping, silencing, inhibition, and routing to Slack, Discord, email, PagerDuty, Telegram, or webhooks. Its strengths: alerts live in version-controllable YAML files (alerts-as-code), and its routing trees handle genuinely complex logic. Its cost: you’re writing YAML and PromQL, not clicking a UI.

Grafana Alerting builds rules through the GUI against any data source, not just Prometheus. Contact points and notification policies are configured visually, and it can even import Prometheus-compatible rules. Its strengths: much gentler learning curve, and it’s your only option if your data source isn’t Prometheus. Its cost: complex routing is weaker than Alertmanager’s trees, and click-configured alerts are harder to version-control.

The homelab recommendation: if you run the full stack, define your core infrastructure alerts (disk filling, host down, RAM pressure) in Prometheus + Alertmanager — they’re code, they’re in Git, they survive a Grafana reinstall — and use Grafana Alerting for ad-hoc or dashboard-adjacent alerts. The two coexist without conflict. If you only have Grafana over a non-Prometheus source, Grafana Alerting is the answer by default.

Comparison table

The homelab stack: what you actually deploy, and what it costs

The standard self-hosted composition — the one our full setup guide walks through end to end — is four pieces:

Those are our first-party tested numbers, not vendor specs. CPU is a non-issue on anything with two modern cores; disk lands at a few gigabytes with default retention (compute your own with the official formula above). A Raspberry Pi 4 with 4GB runs the full stack — put the Prometheus TSDB on an SSD, not an SD card, because the write pattern will eat cheap flash. If you’re budgeting the whole Docker host, our Docker RAM planner accounts for the monitoring stack alongside your other services.

Can you skip one? Prometheus without Grafana works — your alerts still fire — but you lose the visibility that’s half the point. Grafana without Prometheus only makes sense when your metrics already live in another backend. For 95% of homelabs, the answer is both, and at ~600MB total the economics don’t justify agonizing over it.

When the full stack is overkill

Honest caveat: if all you want is “is my server up and roughly how busy is it,” Prometheus + Grafana is more machinery than you need. Lighter single-binary tools — Beszel, Netdata, Glances — give you instant per-host visibility with near-zero setup; we compare them in our lightweight monitoring roundup. The Prometheus stack earns its place when you want history (“what was the CPU doing three hours before the crash?”), cross-host dashboards, and real alerting. And if you’d rather not host it at all, Grafana Cloud’s free tier (10K series, 14-day retention, 3 users) exists — at the philosophical cost of shipping your homelab’s metrics to someone else’s cloud.

Bottom line

Prometheus is the data layer; Grafana is the glass. Deploy both — via our step-by-step stack guide or as an addition to your Docker Compose stack — put your load-bearing alerts in Alertmanager where they’re version-controlled, use Grafana’s alerting for everything visual, and the whole thing costs you well under a gigabyte of RAM. The “vs” was never real; the layering is.