The choice between Grafana Cloud and a self-hosted Grafana stack rarely comes down to the dashboards. Grafana the visualization layer is the same open-source code either way. What you're really deciding is who runs the storage engines underneath it — Prometheus or Mimir for metrics, Loki for logs, Tempo for traces — and who gets paged at 3am when one of them falls over.
We set up both paths for a mid-sized service emitting metrics, logs, and traces, and the split is cleaner than most "it depends" answers suggest. Here's how to decide without running a six-month bake-off.
What you are actually choosing between
Self-hosted Grafana means you deploy and operate the full stack yourself. The Grafana OSS binary is genuinely free with no seat limits, but it's only the front end. To make it useful you also run a time-series database (Prometheus for smaller setups, Mimir once you outgrow a single Prometheus), Loki for logs, and Tempo for traces. Each of those needs object storage, retention tuning, compaction, and capacity planning. The software costs nothing; the engineer-hours and the storage bill are the real line items.
Grafana Cloud is the managed version of that same stack. You ship your metrics, logs, and traces to Grafana Labs' endpoints and they run Mimir, Loki, and Tempo for you. There's a free tier that's legitimately usable for a small project or a side service, paid usage-based tiers above it, and an enterprise tier with SSO, audit logs, and support SLAs. You trade per-unit ingestion cost for never touching a compaction config.
A third option sits between them: self-host Grafana OSS for dashboards but point it at managed backends, or vice versa. Grafana the dashboard tool connects to remote data sources regardless of where it runs, so these aren't all-or-nothing decisions.
Grafana, Loki, Tempo, and Mimir are all AGPLv3 open source. "Self-hosted" here means you operate them — it does not mean a stripped-down version. The feature gap that matters is in the managed convenience (turnkey scaling, support, SSO on the free-ish tiers), not in the dashboarding itself.
The cost crossover nobody quotes upfront
The honest framing is total cost of ownership, not sticker price. Self-hosting looks free until you price the three things it actually consumes: object storage for long-retention metrics and logs, compute for the ingesters and queriers, and engineer time to keep all of it healthy.
For a small footprint — a handful of services, modest log volume, two-week retention — self-hosting on a single box or a small cluster is cheap in dollars but front-loads setup time. Grafana Cloud's free tier often covers this same footprint at zero dollars, which is why early-stage projects rarely self-host first. You'd be paying in evenings to save nothing.
The crossover arrives with log and metric volume. Managed observability is billed largely on ingestion and active series, and high-cardinality metrics or chatty debug logs make that number climb fast. A service emitting tens of gigabytes of logs a day, or carrying hundreds of thousands of active series from per-request labels, can hit a monthly Cloud bill that pays for a dedicated infra engineer's time several times over. That's the point where self-hosting Mimir and Loki on your own object storage starts winning on raw cost — if you already have the operational competence to run them.
Free-tier and usage-tier limits on Grafana Cloud change periodically — series counts, log GB, and retention windows have all moved over past years. Treat any specific number you read (including ours) as a starting point and confirm against the current pricing page before you commit a budget. Don't architect around a free-tier ceiling that may shift.
The trap on the self-hosted side is underpricing your own labor. Loki's index and chunk lifecycle, Mimir's horizontal scaling, Tempo's trace retention — each is well documented and each has sharp edges. The cost isn't the initial deploy; it's the on-call rotation that now owns a stateful, high-throughput data pipeline. If your team is three engineers shipping product, that rotation is expensive in ways that don't appear on a cloud invoice.
When self-hosting earns its keep
Three situations make self-hosting the clear call, and they're worth being honest about because the rest of the time managed wins.
First, data residency and compliance. If logs or metrics carry regulated data that legally cannot leave your infrastructure or your region, sending them to a third-party ingestion endpoint is a non-starter regardless of cost. Self-hosting keeps the data inside your boundary.
Second, volume past the crossover with the team to match. Once ingestion bills dwarf the cost of an engineer and you already employ people who can run distributed storage, owning the stack is straightforwardly cheaper and gives you tuning control — retention per stream, cardinality limits, query resource isolation — that managed tiers expose only partially.
Third, deep customization. Custom plugins, unusual data sources, air-gapped environments, or integration with internal auth systems can be simpler when you own the deployment end to end.
For nearly everyone else — small teams, products where observability is a means not the mission, anyone who'd rather ship features than tune compactors — Grafana Cloud's managed path is the lower-regret default. You can always move later; the dashboards and most of the query languages port across because the underlying projects are the same.
Start on Grafana Cloud's free tier, instrument honestly, and watch your active series and log GB for a month. That real usage number tells you exactly where you'd land on a paid tier — and whether you're anywhere near the volume where self-hosting math flips. Decide with your data, not a hypothetical.
The meta-point: this is a reversible, measurable decision. Instrument first on the managed path, read your actual cardinality and volume, and let those numbers — not a vendor pitch or a self-hosting purist — pick the side.
Originally published at pickuma.com. Subscribe to the RSS or follow @pickuma.bsky.social for new reviews.
Top comments (0)