Datadog is a capable Kubernetes monitoring platform. It is also one of the most expensive ways to monitor a Kubernetes cluster, with several pricing mechanisms that are uniquely punishing in containerized environments. A 50-node cluster that costs $750/month for infrastructure monitoring alone can quickly reach several thousand dollars per month once APM, logs, custom metrics, and container overages are factored in. And a single agent misconfiguration can multiply that cost by ten.
This guide covers why Datadog gets expensive, specifically on Kubernetes, what the best alternatives are in 2026, and how to choose based on your cluster size, team capacity, and data residency requirements.
Key Takeaways
- Datadog bills per Kubernetes node at $15/node/month (Pro, annual). A 100-node cluster costs $1,500/month for infrastructure monitoring alone, before APM ($31/node/month), logs ($0.10/GB), or container overages
- Datadog includes 5 containers free per host on the Pro plan and 10 on Enterprise. Additional containers cost $0.002 per container per hour or $1 per container per month prepaid. A 50-node cluster running 20 pods per node incurs overage charges on 15 containers per node, or 750 containers of overage at $750/month
- The most dangerous Datadog Kubernetes billing trap: deploying the agent per pod instead of per node. A 50-node cluster running 10 pods per node becomes 500 billable hosts instead of 50, a 10x cost increase from a single DaemonSet misconfiguration
- A standard Kubernetes cluster with node-exporter, kube-state-metrics, and cAdvisor enabled in Datadog can generate 10,000+ custom metrics before any application instrumentation. The Pro plan includes 100 custom metrics per host. Overages cost $5 per 100 metrics per month
- All OTel metrics sent to Datadog count as custom metrics, making OpenTelemetry-instrumented Kubernetes clusters particularly expensive
- CubeAPM covers Kubernetes monitoring (clusters, nodes, pods, containers, CronJobs), APM, logs, infrastructure, RUM, and synthetic monitoring in one self-hosted platform at $0.15/GB with no per-node, per-container, or custom metric fees
Why Datadog Gets Expensive on Kubernetes
Kubernetes introduces billing mechanics that do not exist in traditional VM environments. Understanding them is necessary to evaluate alternatives accurately.
- Per-node billing that multiplies with every module: Datadog charges per Kubernetes node for infrastructure monitoring ($15/node/month, Pro annual). APM adds another $31/node/month on the same nodes. Both are billed independently. A 50-node cluster running APM costs ($15 + $31) × 50 = $2,300/month before logs, custom metrics, or containers.
- The DaemonSet misconfiguration trap: The correct Datadog deployment on Kubernetes is one agent per node via DaemonSet. If the agent is mistakenly deployed per pod, each pod registers as a separate billable host. A 50-node cluster running 10 pods per node becomes 500 billable hosts instead of 50: a 10x cost increase that appears on the next invoice without warning. Confirmed from the official Datadog pricing page: “a host is any physical or virtual OS instance… in the case of Kubernetes: a node.”
- kube-state-metrics and cAdvisor generate thousands of custom metrics: Deploying standard Kubernetes monitoring tooling (node-exporter, kube-state-metrics, cAdvisor) generates 10,000+ metrics in a typical cluster before any application-level instrumentation is added. The Pro plan includes 100 custom metrics per host. At 50 nodes, that is 5,000 included custom metrics against a cluster generating 10,000+. Overages cost $5 per 100 custom metrics per month.
- All OTel metrics count as custom metrics: Teams migrating to OpenTelemetry instrumentation discover that every OTel metric sent to Datadog counts as a custom metric, including the standard semantic convention metrics that OTel SDKs emit by default. A Kubernetes cluster fully instrumented with OTel can see its custom metric count double or triple.
- Container overages beyond 5 per host (Pro) or 10 per host (Enterprise): Datadog includes 5 containers free per host on the Pro plan and 10 on Enterprise (confirmed from datadoghq.com/pricing). Additional containers are $0.002 per container per hour or $1 per container per month on a prepaid basis. A 50-node cluster running an average of 20 pods per node incurs overage charges on 15 containers per node, equalling 750 containers of overage at $750/month on top of infrastructure and APM costs.
- 99th percentile billing amplifies autoscaling costs: Kubernetes clusters autoscale. Datadog meters nodes hourly and bills at the 99th percentile of usage for the month. A two-day scaling event that doubles node count sets the bill for the full month at or near the higher level.
New LLM Observability pricing effective May 1, 2026. Datadog introduced new LLM Observability pricing effective May 1, 2026. Teams using Datadog for AI/LLM monitoring should verify current rates directly at datadoghq.com/pricing before budgeting.
What Kubernetes Monitoring Requires
Before evaluating alternatives, it is worth being clear about what complete Kubernetes monitoring covers. The layers are:
| Layer | What to monitor | Key data sources |
| Cluster state | Node status, pod phase, deployment health, ReplicaSet readiness | kube-state-metrics |
| Node-level resources | CPU, memory, disk, network per node | node-exporter (DaemonSet) |
| Container-level resources | CPU and memory per container, throttling | cAdvisor (embedded in kubelet) |
| Pod and workload logs | Stdout/stderr from all containers | Log collector (DaemonSet) |
| Application traces | Request spans across services running in the cluster | OTel SDK and Collector |
| Kubernetes events | Pod evictions, OOM kills, scheduling failures, back-off events | Kubernetes Events API |
| Cost attribution | Resource cost per namespace, deployment, or team | OpenCost or equivalent |
Any serious Kubernetes monitoring alternative needs to cover at a minimum the first four layers. APM traces and cost attribution are valuable additions.
Top Datadog Alternatives for Kubernestes Monitoring
1. CubeAPM
CubeAPM is a full-stack observability platform that runs inside your own infrastructure. Its Kubernetes monitoring covers clusters, nodes, pods, containers, namespaces, and CronJobs with real-time performance insights. It tracks resource usage, exit codes, pod restart counts, scheduling failures, OOM events, and missed CronJob schedules.
Because CubeAPM is self-hosted and OTLP-native, OTel metrics from your Kubernetes workloads do not count as custom metrics. There is no such billing concept. All telemetry from kube-state-metrics, node-exporter, cAdvisor, or OTel SDKs is ingested at the same flat rate with no per-metric or per-node surcharges.
Pricing: $0.15/GB ingestion. No per-node fees. No per-container fees. No per-user fees. No custom metric taxes.
For a 50-node cluster generating 50GB/day of metrics, logs, and traces, the monthly bill is approximately $225. On Datadog Pro with APM enabled, the same cluster costs over $2,300/month before logs, custom metric overages, or container fees.
Kubernetes-specific features confirmed from cubeapm.com/platform/kubernetes-monitoring:
- Kubernetes monitoring: clusters, nodes, pods, containers, namespaces with real-time performance insights
- Tracks pod runs, exit codes, durations, retries, and missed schedules
- Alerts on failed or long-running CronJobs
- Infrastructure monitoring with unlimited retention and full data control
- APM correlated with Kubernetes infrastructure metrics using shared OTel context
- Log management with no data leaving your cloud
Deployment: Installed via Helm into your cluster. All data stays inside your own cloud environment. No telemetry is sent to a third-party SaaS.
Best for: Teams that want a full Datadog replacement for Kubernetes environments with predictable pricing, data residency control, and no per-node billing surprises. Particularly strong for teams handling sensitive workloads that cannot send telemetry to a third-party SaaS.
Limitations: Requires self-hosted deployment. Not suitable for teams that need a fully managed SaaS with no infrastructure responsibilities.
2. Grafana Cloud Kubernetes Monitoring
Grafana Cloud provides a dedicated Kubernetes monitoring product built on its LGTM stack. The Grafana Kubernetes Monitoring Helm chart deploys a complete monitoring solution including Grafana Alloy (the collector), node-exporter (DaemonSet for node metrics), kube-state-metrics (cluster state), cAdvisor (container metrics), Loki (pod logs), Tempo (traces), and OpenCost (cost attribution) in a single Helm install.
Confirmed from official Grafana Cloud Kubernetes documentation (grafana.com/docs/grafana-cloud/kubernetes-monitoring, last updated April 2026):
What the Helm chart deploys and collects:
- Cluster metrics: kubelet, cAdvisor, kube-state-metrics, control plane
- Host metrics: node-exporter DaemonSet (Linux nodes), Windows Exporter (Windows nodes), Kepler (energy usage)
- Node logs and pod logs via Loki pipeline or OTLP
- Profiling via Pyroscope (eBPF, Java, pprof)
- Service integrations for databases and caches running in the cluster
- Cost monitoring via OpenCost with AI-powered savings suggestions
- Curated kube-state-metrics configuration to avoid cardinality explosion
- CronJob and scheduled job tracking with color-coded status and run history
- Outlier pod detection for CPU usage anomalies
- Cluster-to-container navigation with container sizing recommendations
Pricing: Free tier: 2,232 host hours per month, 14-day retention, full platform access. Paid tier: usage-based on active series (metrics), GB ingested (logs), and host hours. No per-node licensing fees.
Best for: Teams already using Prometheus and Grafana who want a managed Kubernetes-native monitoring solution without running the backend themselves. Teams that want OpenCost-based cost attribution built in.
Limitations: Free tier 14-day retention is insufficient for trend analysis over weeks or months. You still deploy agents into your cluster via Helm, but the backends are in Grafana’s cloud.
3. New Relic
New Relic’s Kubernetes monitoring deploys via a DaemonSet and collects node metrics, pod metrics, container metrics, Kubernetes events, and control plane metrics. It includes a Kubernetes Cluster Explorer UI that visualizes the full cluster hierarchy from node to pod to container.
New Relic does not charge per Kubernetes node. All Kubernetes telemetry is ingested as part of the data volume model at $0.40/GB beyond the 100GB free tier (verified from newrelic.com/pricing, May 2026). There are no custom metric overages, no per-container fees, and no billing traps from kube-state-metrics generating thousands of metrics.
Kubernetes-specific features:
- Kubernetes Cluster Explorer: hierarchical visualization of cluster, nodes, namespaces, deployments, pods, and containers
- Automated service map showing connections between pods and external services
- Kubernetes events correlated with metrics and logs using the same entity model
- OpenTelemetry-native: OTel metrics from Kubernetes workloads do not incur extra charges
- Kubernetes integration deployed via Helm or the New Relic CLI
Pricing: Free tier includes 100GB/month, one full platform user, unlimited basic users, and all Kubernetes monitoring capabilities, including APM, infrastructure, logs, and distributed tracing. Paid ingest is $0.40/GB beyond the free tier.
Best for: Teams that want a full-stack SaaS Kubernetes monitoring alternative to Datadog with a genuine free tier and no per-node pricing. Teams already planning to use New Relic for APM and logs that want unified Kubernetes visibility.
Limitations: Data leaves your infrastructure and flows to New Relic’s cloud. Free tier has 8-day retention for most data types. Full platform user costs can grow as the engineering team expands.
4. Prometheus Operator and kube-prometheus-stack
The CNCF-standard open-source approach for Kubernetes monitoring is the Prometheus Operator with the kube-prometheus-stack Helm chart. The chart deploys Prometheus, Alertmanager, Grafana, node-exporter, kube-state-metrics, and pre-built dashboards and alerting rules derived from the kubernetes-mixin project maintained by Grafana Labs.
What kube-prometheus-stack provides:
- node-exporter DaemonSet for node-level CPU, memory, disk, and network metrics
- kube-state-metrics for cluster state: pod phase, deployment health, ReplicaSet readiness
- cAdvisor metrics via kubelet for container-level resource usage
- Pre-built Grafana dashboards for all Kubernetes monitoring layers
- Alertmanager with pre-configured alert rules from kubernetes-mixin
- Prometheus Operator CRDs (ServiceMonitor, PodMonitor, PrometheusRule) for managing scrape targets as Kubernetes resources
For long-term metric storage: Prometheus is not designed for multi-year retention. Add Thanos for high-availability long-term storage, or use Grafana Mimir.
Pricing: Infrastructure cost only. No licensing fees.
Best for: Infrastructure-mature teams with a dedicated platform engineer or SRE who can own the monitoring stack. Teams that have hit unsustainable Datadog bills and want to eliminate licensing costs entirely.
Limitations: Operating Prometheus at cluster scale requires meaningful engineering investment. High-cardinality metrics common in large Kubernetes clusters can cause Prometheus memory pressure. Logs and traces require separate tooling (Loki and Tempo). No managed option.
Comparison: Kubernetes Monitoring Capabilities
| Capability | CubeAPM | Grafana Cloud | New Relic | Prometheus + Grafana |
| Node metrics (CPU, memory, disk) | Yes | Yes (node-exporter) | Yes | Yes (node-exporter) |
| Pod and container metrics | Yes | Yes (cAdvisor) | Yes | Yes (cAdvisor) |
| Cluster state (kube-state-metrics) | Yes | Yes (curated, cardinality-safe) | Yes | Yes |
| Pod and node logs | Yes | Yes (Loki) | Yes | Via Loki (separate) |
| Distributed traces from workloads | Yes (APM) | Yes (Tempo) | Yes | Via Tempo (separate) |
| Kubernetes events | Yes | Yes | Yes | Via Alertmanager |
| CronJob monitoring | Yes | Yes (color-coded, run history) | Yes | Via kube-state-metrics |
| Cost attribution (OpenCost) | Yes | Yes (built-in with AI suggestions) | Partial | Via OpenCost (separate) |
| Control plane metrics | Yes | Yes | Yes | Yes |
| Per-node billing | No | No | No | No (infra cost only) |
| Custom metric overage risk | No | No | No | No |
| OTel metrics billed as custom metrics | No | No | No | No |
| Data stays in your cloud | Yes | No | No | Yes |
| Managed service | No | Yes | Yes | No |
How to Choose
| Your situation | Best choice |
| Full Datadog replacement, data must stay in your cloud, no per-node fees | CubeAPM |
| Want managed Kubernetes monitoring with OpenCost attribution and AI savings | Grafana Cloud Kubernetes Monitoring |
| Best free SaaS tier for Kubernetes monitoring with no per-node charges | New Relic (100GB/month free, full platform) |
| Maximum cost control, team has SRE capacity to operate the stack | Prometheus Operator with kube-prometheus-stack |
| Already on Grafana Cloud, want Kubernetes metrics to join existing dashboards | Grafana Cloud (extend existing stack) |
| Need APM traces correlated with Kubernetes events and infrastructure metrics | CubeAPM or New Relic |
Summary
Datadog’s per-node billing, 5-container-per-host-per-Pro-plan allotment, custom metric overages from standard Kubernetes tooling, and the DaemonSet misconfiguration trap make it structurally expensive for Kubernetes environments in ways that compound as clusters grow.
CubeAPM eliminates all of these with $0.15/GB ingestion and no per-node, per-container, or per-metric fees, running entirely inside your own cloud. Grafana Cloud provides a managed Kubernetes monitoring stack with OpenCost-based cost attribution and no per-node licensing. New Relic offers the most generous free SaaS tier with full Kubernetes visibility at no per-node charge. The Prometheus Operator with kube-prometheus-stack remains the CNCF-standard zero-licensing-cost option for teams with the capacity to operate it.
| Tool | Per-node fee | Container allotment | OTel metrics extra | Data stays in your cloud | Managed |
| CubeAPM | No | No concept | No | Yes | No (self-hosted) |
| Grafana Cloud | No | No concept | No | No | Yes |
| New Relic | No | No concept | No | No | Yes |
| Prometheus Operator | No (infra cost only) | No concept | No | Yes | No |
| Datadog | Yes ($15/node/month Pro) | 5 free (Pro), 10 free (Enterprise) | Yes (all OTel = custom) | No | Yes |
Disclaimer: Datadog pricing (infrastructure Pro $15/host/month annual, APM $31/host/month annual, 5 containers free per host on Pro and 10 on Enterprise, additional containers $0.002/container/hour or $1/container/month prepaid, custom metrics $5/100 metrics beyond 100 per host on Pro plan, new LLM Observability pricing effective May 1, 2026) verified directly from datadoghq.com/pricing and docs.datadoghq.com/account_management/billing as of May 2026. New Relic pricing (100GB/month free, $0.40/GB beyond free tier) verified directly from newrelic.com/pricing as of May 2026. Grafana Cloud Kubernetes Monitoring features (node-exporter, kube-state-metrics, cAdvisor, OpenCost, Alloy, CronJob tracking, outlier pod detection) verified from grafana.com/docs/grafana-cloud/kubernetes-monitoring and grafana.com/products/cloud/kubernetes as of May 2026. CubeAPM Kubernetes monitoring features and pricing verified from cubeapm.com/platform/kubernetes-monitoring and cubeapm.com/pricing as of May 2026.
Also read:
What Are the Cheapest Alternatives to Datadog for Startups?