Last updated: July 2026
Grafana Cloud and Datadog bills scale with metrics cardinality, log volume, and retention — not with how much compute you actually need. For teams running their own Kubernetes clusters, VPS fleets, or CI pipelines, self-hosting the observability stack keeps costs fixed and predictable and gives full control over retention, dashboards, and alerting rules. This guide covers what a self-hosted Prometheus, Grafana and Loki stack actually needs from the underlying host, and how to pick the right VPS for self-hosted Grafana Prometheus workloads without over- or under-provisioning.
Why teams are dropping hosted observability
Hosted monitoring vendors charge per active series, per log GB ingested, and per user seat. Costs climb quietly as teams add exporters, node-level metrics, and application traces. A self-hosted Prometheus, Grafana and Loki stack turns that into a fixed monthly VPS cost with predictable scaling: add RAM and disk as retention grows, rather than watching a usage-based invoice creep upward over time. The tradeoff is that you own capacity planning — which is straightforward once you understand the two things that actually drive resource usage: active series count and retention window.
Sizing a Prometheus, Grafana and Loki stack correctly
Three components share the box, and each stresses a different resource:
- Prometheus is memory-hungry. Its time-series database keeps recent chunks in RAM before flushing to disk, so memory pressure scales with the number of active series (hosts, containers, and label combinations you scrape), not raw data volume.
- Grafana itself is lightweight — a handful of vCPU cycles for dashboard queries and rendering. It rarely dictates sizing on its own.
- Loki is disk-and-I/O bound. Log chunks compress well, but ingest throughput and query speed depend heavily on storage speed, which is why NVMe matters for chunk-heavy workloads like Loki far more than raw capacity does.
In practice, retention window is the lever that matters most once you're past a handful of scrape targets: a 15-day retention window needs meaningfully less disk than 90 days, and every additional week compounds. Plan disk headroom around your target retention before you plan CPU.
Choosing a VPS for self-hosted Grafana and Prometheus
X-Zone's KVM VPS lineup runs from 2GB/1vCPU up to 32GB/8vCPU, all on NVMe storage with unmetered 1 Gbps bandwidth and full root access — which covers most self-hosted monitoring deployments without needing a dedicated box. A practical way to match a tier to a workload:
| Monitoring footprint | Suggested tier | Specs | Notes |
|---|---|---|---|
| Single exporter / quick test | Nano | 2GB/1vCPU/40GB NVMe — EUR4/mo | Fine for trying Prometheus + Grafana against a handful of targets; too tight on RAM to add Loki or run production long-term |
| Single small cluster / homelab, short retention | Micro | 4GB/2vCPU/80GB NVMe — EUR6/mo | Prometheus + Grafana comfortably; keep Loki retention modest |
| Small production fleet, standard retention | Starter | 8GB/2vCPU/120GB NVMe — EUR10/mo | Headroom for more scrape targets and Loki alongside Prometheus |
| Growing fleet, longer retention or more exporters | Basic | 16GB/4vCPU/160GB NVMe — EUR16/mo | More comfortable memory ceiling for higher active-series counts |
| Multi-team or multi-cluster monitoring | Pro | 24GB/6vCPU/200GB NVMe — EUR30/mo | Room to separate Prometheus and Loki workloads, or run long-term storage sidecars |
| Large fleet, high cardinality, extended retention | Business | 32GB/8vCPU/300GB NVMe — EUR58/mo | Top of the KVM lineup before stepping up to Dedicated |
Because billing is hourly and capped at the monthly rate, it's cheap to start on Starter or Basic, watch actual memory and disk usage under real scrape load for a week, and resize up only if needed — no need to guess correctly on day one.
Self-hosted Loki VPS considerations
Log volume is the wildcard in any capacity plan. A self-hosted Loki VPS setup that only ingests structured application logs from a handful of services behaves very differently from one ingesting verbose debug-level logs across dozens of containers. Two practical guardrails: keep Loki's retention shorter than Prometheus's metrics retention unless you have a specific compliance reason not to, and route noisy debug logs through a separate stream or drop rule rather than let them inflate chunk storage on the same NVMe volume your metrics rely on. Because NVMe throughput is shared across Prometheus writes, Loki writes, and Grafana queries on a single VPS, keeping log volume in check protects query latency for both tools.
Docker vs bare-metal install on the VPS
Most self-hosted stacks run Prometheus, Grafana and Loki as containers via Docker Compose — it keeps upgrades clean and configuration reproducible. Full root KVM access means nothing is locked down: install Docker directly, or run each service as a systemd unit if you prefer a bare install. Either approach benefits from unmetered bandwidth, since Grafana dashboards, remote-write endpoints, and Loki push traffic all move over the same network interface without a data cap to watch.
Getting the host itself right
Before touching Helm charts or Compose files, the underlying VPS needs to actually support the workload: full root, a real OS choice (Ubuntu, Debian, AlmaLinux, Rocky, or CentOS all work fine for this stack), and NVMe storage so Prometheus's write-ahead log and Loki's chunk store aren't waiting on disk I/O. Deployment across X-Zone's 12 datacenter cities also means the monitoring host can sit close to the infrastructure it's actually watching, which keeps scrape and remote-write latency low for geographically distributed fleets.
When to move up to Dedicated
A single VPS tier tops out around 32GB RAM and 8 vCPU, which comfortably runs Prometheus, Grafana and Loki for most single-team or mid-size fleets. Once you're monitoring dozens of clusters, running long-term storage backends alongside Prometheus, or ingesting high-cardinality metrics from hundreds of services, a dedicated server makes more sense — X-Zone's dedicated lineup scales from dual-Xeon configurations up to dual EPYC 9754 with 512 threads and 1TB RAM, giving a monitoring fleet room to grow for years before needing to shard across multiple hosts.
Verdict
Self-hosting Prometheus, Grafana and Loki is a straightforward way to cut recurring observability costs and keep full control over retention and dashboards, as long as the underlying VPS is sized around actual active-series count and log volume rather than guesswork. X-Zone Servers' NVMe KVM lineup — full root, unmetered 1 Gbps, hourly billing capped at the monthly rate — covers the sizing curve from a small single-cluster setup up through a multi-team monitoring stack, with a clear path to Dedicated once the fleet outgrows a single VPS.