Grafana, Prometheus, and Loki Replace Datadog for the Price of an Old PC Under Your Desk

On July 10, 2026, Prometheus shipped version 3.13.1, a patch release eleven days after 3.13.0 went out. Grafana followed with 13.1.1 on July 21, its second maintenance release of the 13.x line. Loki published 3.6.13 on July 24 while the 3.7 branch reached its fourth iteration. Three separate projects, one release cadence, and one shared capability: covering what Datadog charges $15 per host per month just for infrastructure monitoring.

By mid-2026, the Grafana + Prometheus + Loki stack has become the most coherent open-source answer to SaaS observability platforms. It does not require a Kubernetes cluster or a dedicated ops team to get started — a Docker Compose file on a Linux box, one metrics exporter per host, and you have a dashboard that matches a Datadog Pro account.

The Datadog bill in 2026

Datadog’s model is pricing-first. As of July 2026, the rate card reads:

• Infrastructure Monitoring — $15 per host per month, billed annually, or $18 on-demand. Covers 1,000+ integrations and core metrics.
• APM — $31 per host per month bundled with Infrastructure, $36 standalone. APM Enterprise reaches $47 per host.
• Log Management — $0.10 per ingested gigabyte, with a default 15-day retention for on-demand accounts.
• Continuous Profiler — $12 per host, plus $2 per additional container beyond the included four.

A typical homelab of five machines (one main server, two mini PCs, a NAS, and a build box) with APM would cost (15 + 31) × 5 = $230 per month, or $2,760 per year, logs not included. Scale to ten nodes and you are looking at $5,520 per year. At that rate, even a brand-new Intel N305 at $250 with 16 GB of RAM pays for itself in two months.

And Datadog has no incentive to drop prices: Gartner named it a Leader in the 2026 Magic Quadrant for Observability Platforms, and the company just added Bits AI Agents — a conversational AI assistant that answers infrastructure questions in plain English. The strategy is straightforward: more value, not lower cost.

What the Grafana stack covers

The Grafana/Prometheus/Loki trinity did not appear from nowhere. Prometheus was born at SoundCloud in 2012, joined the CNCF in 2016 as the second hosted project after Kubernetes, and passed 65,000 GitHub stars by July 2026. Grafana has been around since 2014 and now holds 75,000 stars. Loki, the youngest of the three, was designed as the logging counterpart to Prometheus — same label-based indexing model, same compressed storage philosophy, same PromQL-inspired query language.

Together, the three projects cover exactly the triad that a SaaS platform charges a premium for:

• Metrics — Prometheus scrapes /metrics endpoints from every service every 15 to 60 seconds. node_exporter exposes CPU, RAM, disk, network, sensor temperatures, and systemd statistics. Once the data is in the time-series database, PromQL enables queries like rate(node_cpu_seconds_total{mode="idle"}[5m]) to track real-time CPU utilization.
• Logs — Loki ingests logs via Promtail or Grafana Alloy, compresses them into chunks, and indexes them by labels only (not by content). The result: a 10× to 50× storage reduction compared to Elasticsearch for equivalent log volume. LogQL lets you filter, aggregate, and transform logs using the same syntax as PromQL.
• Dashboards — Grafana connects to both as native data sources, with no extra plugins needed. Dashboards export as JSON and are shared on grafana.com/dashboards, where the community maintains thousands of ready-to-import templates, including a Node Exporter Full dashboard covering 90% of homelab needs in one click.

The fourth pillar — distributed traces — is handled by Grafana Tempo, also open-source and also insertable into the same docker-compose.yml. Tempo is not included in this article to keep the stack at three services, but the mechanism is identical.

A docker-compose that works

Here is the minimal stack for a homelab. It assumes a ./config/ directory with config files alongside the compose file, and exposes Grafana on port 3000.

services:
  prometheus:
    image: prom/prometheus:v3.13.1
    container_name: prometheus
    volumes:
      - ./config/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
    restart: always

  node_exporter:
    image: quay.io/prometheus/node-exporter:v1.10.2
    container_name: node_exporter
    pid: host
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.rootfs=/rootfs'
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--collector.systemd'
      - '--collector.processes'
    restart: always

  loki:
    image: grafana/loki:3.7.4
    container_name: loki
    volumes:
      - ./config/loki-config.yml:/etc/loki/local-config.yaml
      - loki_data:/loki
    command: -config.file=/etc/loki/local-config.yaml
    restart: always

  promtail:
    image: grafana/promtail:3.7.4
    container_name: promtail
    volumes:
      - ./config/promtail-config.yml:/etc/promtail/config.yml
      - /var/log:/var/log:ro
      - /var/lib/docker/containers:/var/lib/docker/containers:ro
    command: -config.file=/etc/promtail/config.yml
    restart: always

  grafana:
    image: grafana/grafana:13.1.1
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=changeme
    restart: always

volumes:
  prometheus_data:
  loki_data:
  grafana_data:

The minimal Prometheus config (config/prometheus.yml) scrapes node_exporter and Prometheus itself every 15 seconds:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
  - job_name: 'node'
    static_configs:
      - targets: ['node_exporter:9100']

Five containers, 300 MB of RAM at idle before any log ingestion, and a disk footprint that varies with data volume — budget 2 to 4 GB per month for the metrics of a 5-machine homelab, and 5 to 20 GB per month for logs depending on how verbose your services are.

To add another host, install node_exporter on the remote machine and add its target to prometheus.yml. No license key, no pricing tier, no marginal cost calculation.

Alerts that warn you before your users do

Prometheus’s real strength is not collection but its built-in alerting engine. Alert rules are written in PromQL inside a YAML file, and Alertmanager handles routing, grouping, and silencing:

groups:
  - name: homelab
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg(rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "CPU usage above 80% for 10 minutes on {{ $labels.instance }}"
      - alert: DiskFillingUp
        expr: (node_filesystem_avail_bytes / node_filesystem_size_bytes) < 0.10
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Disk {{ $labels.mountpoint }} below 10% free on {{ $labels.instance }}"
      - alert: ServiceDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.job }} is down on {{ $labels.instance }}"

Alertmanager routes these alerts to a dozen native destinations — email, Slack, Discord, Telegram, PagerDuty, Webhook — without a paid third-party API. A Slack route takes ten lines:

route:
  receiver: 'slack-homelab'
receivers:
  - name: 'slack-homelab'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/T...'
        channel: '#alerts'
        title: '{{ .Status | toUpper }} - {{ .CommonLabels.alertname }}'
        text: '{{ .CommonAnnotations.summary }}'

Where Datadog bills alerting as a feature bundled into the $31/host APM tier, the self-hosted stack covers it with a YAML file and a free webhook. PromQL has a real learning curve — budget half a day for your first ten rules — but it pays for itself the first time an outage gets caught before a user reports it.

What Datadog still does better

Datadog retains a genuine edge in four areas. Turnkey integrations come first: 1,000 vendor-maintained connectors, from Palo Alto firewalls to F5 load balancers, activated by checkbox with zero configuration. On the Grafana side, equivalent connectors exist, but the AWS CloudWatch plugin or the Zabbix plugin require manual setup that can take an hour per data source.

Conversational AI is next: Bits AI, integrated into Datadog since 2025, answers questions like “why is my application slow right now?” in natural language and automatically launches an investigation spanning metrics, logs, and traces. Grafana does offer an AI assistant in preview on the 13.x release, but it is limited to generating PromQL queries — it does not investigate.

Long-term retention: Datadog retains metrics for up to 15 months and logs for up to 30 days on standard plans, with automatic storage scaling. Prometheus, by design, stores everything locally — a 30-day retention on a 256 GB SSD works for a homelab, but beyond that you need to pair Prometheus with Thanos or Mimir to offload long-term storage to an object store (S3, MinIO).

Compliance, finally: Datadog is certified SOC 2 Type II, HIPAA, PCI DSS, ISO 27001. A self-hosted stack carries none of these certifications, and the burden falls on you to demonstrate compliance if an audit requires it. For personal use or a small team, this is a non-issue; for a regulated company, it can become a blocker.

The verdict

If you run a homelab of 2 to 20 machines and are comfortable with Docker Compose, the Grafana + Prometheus + Loki stack replaces Datadog with no real functional loss on core monitoring — metrics, logs, dashboards, and alerting — at a recurring cost near zero beyond electricity. The initial setup time (half a day for a clean docker-compose, another half for alert rules) is easily offset by the absence of a monthly bill.

If you manage a fleet of more than 50 machines, your logs exceed 50 GB per day, or you have a compliance obligation (SOC 2, HIPAA), stick with Datadog — the time you will spend configuring Thanos, managing distributed retention, and documenting compliance will cost more than the subscription. The middle ground (20 to 50 machines) is where the choice hinges on how you value your admin time: if you already have someone managing infrastructure part-time, switching to the self-hosted stack breaks even within six months.

For a homelab, the math is settled: the price of an old PC under your desk versus $276 per month for 5 machines. Even if you price your time at $100 an hour, you come out ahead by the end of the first morning.

References

• Grafana v13.1.1, grafana/grafana, July 21, 2026.
• Prometheus v3.13.1, prometheus/prometheus, July 10, 2026.
• Loki v3.6.13, grafana/loki, July 24, 2026.
• Prometheus Overview, Prometheus documentation.
• Grafana OSS Documentation, Grafana Labs.
• Grafana Loki Documentation, Grafana Labs.
• Datadog Pricing, Datadog, accessed July 2026.
• Gartner Magic Quadrant for Observability Platforms 2026, Gartner/Datadog, 2026.
• node_exporter, prometheus, GitHub repository.
• Alertmanager Configuration, Prometheus documentation.