TL;DR
- The problem: Datadog's unpredictable and high costs are not just a pricing issue. They are a symptom of an architecture that scales with high-cardinality data by passing significant costs on to the user. This leads to expensive custom metrics, dual charges for ingestion and querying, and penalties for dynamic infrastructure.
- The solution is architectural: The most effective alternative isn't just a cheaper tool but one built on a modern columnar data engine designed for analytics at scale. Solutions like ClickHouse Observability, built on the ClickHouse columnar database, are designed specifically for the speed and scale that modern observability demands.
- ClickHouse Observability's advantage: By unifying logs, metrics, and traces in a single high-performance datastore, ClickHouse Observability delivers sub-second queries on petabytes of data, high data compression (14x), and a simple, predictable pricing model. It solves the high-cardinality problem natively, offering massive cost savings and performance gains over traditional platforms. That efficiency keeps unsampled telemetry and history affordable, giving agents the context and fast concurrent queries to investigate without API limits.
- This guide: We compare eight alternatives, focusing on their underlying architecture, pricing models, and ability to handle high-cardinality data, helping you choose a solution that scales without surprise bills.
It’s a familiar story for many DevOps teams: the monthly observability bill is spiraling out of control. When a Hacker News thread about a single company's $65 million Datadog bill went viral, it unleashed a wave of similar complaints about complex, unpredictable billing. But these high costs are symptoms of a deeper architectural problem. Many legacy platforms were not built for the reality of modern systems, which generate huge volumes of high-cardinality data from ephemeral infrastructure like Kubernetes. This mismatch leads to punitive fees for custom metrics and dual charges for ingestion and querying. This guide provides a technically-grounded comparison of alternatives, focusing on the core architecture that solves these fundamental problems of performance and cost at scale.
Why Datadog's pricing model struggles at scale
Datadog is a powerful platform, but its pricing model can lead to unpredictable and escalating costs, especially for organizations operating at scale. These financial pressures are not arbitrary. They are symptoms of an architecture that, while capable, becomes prohibitively expensive when applied to the high-volume, high-cardinality data that defines modern observability.
Here’s a breakdown of the key challenges:
| Challenge | Description | Architectural cause |
|---|---|---|
| The high-cardinality tax | Exploding costs for custom metrics when adding tags with many unique values (e.g., container_id, customer_id). | Traditional indexing technology struggles to efficiently manage and query a vast number of unique metric time series. |
| The ingestion vs. query penalty | Paying once to ingest logs and a second, higher fee to index them for querying, forcing teams to limit what they analyze. | Data is stored in a way that is not optimized for fast, ad-hoc analytical queries without expensive, upfront indexing. |
| The per-host problem | Costs for APM and infrastructure are tied to the number of hosts, penalizing modern, ephemeral architectures like Kubernetes. | A billing model tied to a legacy unit (hosts) that fails to represent modern, container-based workloads where host counts are dynamic and often irrelevant. |
The high-cardinality tax
A primary driver of surprise bills is the "custom metric tax." Datadog's billing for custom metrics is based on cardinality: the number of unique combinations of a metric name and its tags (e.g., host, customer_id, container_id). Adding a single tag with many unique values, a common practice when using frameworks like OpenTelemetry, can cause the volume of billable metric time series to explode. At scale, custom metrics can account for over half of a total Datadog bill. This occurs because traditional monitoring systems often rely on indexing technologies that struggle to efficiently manage and query a vast and ever-growing number of unique label combinations.
The ingestion vs. query penalty
For log management, Datadog uses a dual-cost model that charges teams twice for the same data. You first pay an ingestion fee simply to collect and process the logs (e.g., $0.10 per GB). To make those logs searchable and useful for real-time debugging, you must pay a second, much higher fee to index them for analysis (e.g., $1.70 per million log events). This creates a difficult choice between budget and visibility, forcing engineering teams to be highly selective about what data they can afford to analyze, undermining the goal of comprehensive observability.
The per-host problem
Finally, tying core service costs for infrastructure monitoring and APM to the number of hosts penalizes modern, dynamic architectures. In environments like Kubernetes, where containers and nodes are ephemeral and scale on demand, the "per-host" metric is a fluctuating, unpredictable multiplier for costs.
This model forces teams into a highly undesirable trade-off: either compromise their architecture to minimize billable hosts — prioritizing cost over resilience — or accept "observability gaps" by leaving services unmonitored to stay within budget.
The 8 best Datadog alternatives for scalable observability
This table provides a quick summary of the 8 alternatives discussed below, helping you identify the best potential fits based on your primary needs and technical preferences.
| Alternative | Core architecture | Best for high cardinality? | Primary strength | Best for |
|---|---|---|---|---|
| ClickHouse Observability | Unified columnar database | Yes, natively | Cost efficiency and fast investigations for SREs and agents. | Teams using or adopting OpenTelemetry that want full-fidelity telemetry and agent investigations with a fully managed backend. |
| New Relic | Proprietary SaaS | No, can be costly | Deep APM insights | Enterprises needing mature, all-in-one APM without strict budget constraints. |
| Dynatrace | Proprietary SaaS / OneAgent | No, can be costly | AI-powered automation | Large enterprises needing powerful, automated root-cause analysis in complex environments. |
| Grafana Stack | Siloed (Loki, Mimir, Tempo) | Yes, but complex | Open source & customizable | Teams invested in the Prometheus ecosystem with resources to manage operational complexity. |
| Splunk | Search index | No, struggles at scale | Log management & SIEM | Enterprises focused on deep log analysis and security, with significant budgets. |
| Chronosphere | Cloud-native SaaS (M3) | Yes, via control plane | Traffic shaping & Cost control | Large cloud-native organizations struggling with Prometheus scale and costs. |
| Signoz | Open-source (ClickHouse) | Yes, natively | Unified OSS experience | Teams wanting an open-source, self-hostable Datadog alternative. |
| Dash0 | Serverless OTel Data Lake | Yes | OTel-native & Serverless | Teams fully committed to OpenTelemetry seeking zero ops. |
1. ClickHouse Observability
For teams grappling with the architectural limitations and prohibitive costs of Datadog, ClickHouse Observability offers a fundamentally different approach. ClickHouse Observability treats observability as a data problem—one best solved by combining a highly efficient data engine with a universal data standard. Built on the open-source, columnar database ClickHouse and the industry-standard OpenTelemetry framework, it is an end-to-end solution comprised of high-performance storage and the purpose-built ClickStack UI. This stack is designed from the ground up for high performance, cost-efficiency, and total data portability.
ClickHouse Observability is the turnkey, fully managed product powered by open source ClickStack. Send OpenTelemetry data to one managed endpoint; ClickHouse handles ingestion, schemas, storage, optimization, and scaling. Your agents can investigate through MCP and SQL, with fast concurrent queries and no API limits.
The architecture centers on a unified datastore for logs, metrics, and traces. By strictly adhering to the OpenTelemetry data model, ClickHouse Observability eliminates data silos and stores telemetry as 'wide events' (structured rows containing all context). This OTel-native structure is uniquely suited for ClickHouse’s columnar format, enabling blazing-fast aggregations. Because ClickHouse combines vectorized query execution with multi-core parallel processing, it can process these structured OTel spans with sub-second query times, even on petabytes of data.
Crucially, ClickHouse Observability represents a shift away from proprietary agents. As a deeply OpenTelemetry-native platform, it decouples your instrumentation from your backend. Unlike proprietary vendors that lock your code into their specific libraries, ClickHouse Observability leverages OTel to ensure you own your data generation. By supporting standard query languages like SQL alongside standard OTel semantic conventions, ClickHouse Observability empowers teams to practice "Observability Science": performing deep, ad-hoc analysis to correlate system behavior with business outcomes in a way that is impossible with proprietary DSLs. Joining telemetry with your own business tables requires an appropriately configured ClickHouse database, such as an open source ClickStack deployment or Self-managed ClickHouse Observability.
Choose how you use ClickHouse Observability
- ClickHouse Observability: The fully managed default. Send OpenTelemetry data to one endpoint; ClickHouse handles ingestion, schemas, storage, optimization, and scaling.
- Self-managed ClickHouse Observability: For engineering teams with database expertise seeking the lowest possible unit costs. Your team configures and optimizes the database; ClickHouse Cloud manages the underlying infrastructure.
Both experiences use the ClickStack interface. To run the complete stack on your own infrastructure, choose self-hosted, open source ClickStack.
Key features:
- Unified columnar datastore: Ingests and analyzes OTel logs, metrics, and traces in a single, high-performance database.
- OpenTelemetry native: Built entirely on the OTel standard to prevent vendor lock-in, ensuring you never have to re-instrument your code to switch tools.
- Fast, concurrent queries: Let agents explore possible causes in parallel and reach answers sooner, with no API limits.
- High data compression: Achieves industry-leading data compression of over 15x, dramatically reducing storage costs.
- SQL for deeper investigations: Agents can write expressive SQL to correlate signals, compare historical behavior, and test hypotheses beyond predefined workflows.
- Full-fidelity telemetry and history: Keep high-cardinality logs, metrics, and traces without forced sampling, with affordable long-term retention that gives agents the evidence to compare historical patterns.
- Purpose-built MCP tools: Connect your own agents through the ClickStack MCP server to search logs, follow traces, analyze event patterns and deltas, and query telemetry with SQL alongside code and runbooks.
Pros:
- Future-proofs instrumentation via OpenTelemetry: ClickHouse Observability removes the risk of vendor lock-in at the source. By standardizing on OpenTelemetry for ingestion, you control the "edge" of your observability pipeline.
- Solves the high-cardinality aggregation problem: ClickHouse is designed to handle these aggregations significantly better than alternatives. It allows teams to process high-cardinality OTel tags efficiently on disk or leverage Materialized Views.
- Fast, efficient performance: ClickHouse's columnar design enables high data compression (often exceeding 15x) and fast queries using data skipping via sparse primary indexes.
- Cheap, long-term retention on object storage: Running on ClickHouse Cloud separates storage and compute, allowing you to retain full-fidelity OpenTelemetry data for months or years on low-cost object storage.
- Excellent cost-efficiency at scale: For internal observability workloads, ClickHouse's internal observability deployment has been found to be up to 200x more cost-effective than Datadog. This is a historical result for that workload, not a guaranteed saving for the managed service.
- Simple pricing units: Logs and traces are priced by ingested GB, and metrics by data points. See the pricing page for rates and terms.
- Flexible & Interoperable: Built on a fully open-source (Apache 2.0) foundation, allowing teams to integrate existing data pipelines using popular agents like Vector and FluentD.
Cons:
- Emerging UI and ecosystem: As a newer solution, the ecosystem of out-of-the-box integrations is still growing compared to established vendors.
- Access and alert configuration: The ClickStack UI includes role-based access control and alerts. Your team configures permissions and alert rules for its workflows.
- OpenTelemetry setup: Your team instruments applications and configures source collection. Investigate through the ClickStack UI without SQL expertise, while ClickHouse manages ingestion, schemas, storage, optimization, and scaling.
Best for:
- Cost-conscious organizations operating at a large scale.
- Teams using or adopting OpenTelemetry that want open instrumentation and a fully managed backend for SREs and their agents.
- Teams struggling with high-cardinality data in Elasticsearch or Prometheus.
- Users looking to migrate from expensive logging solutions like Splunk or Datadog.
- Organizations that want to unify their observability and business analytics in a single platform. For analysis over your own business tables, use a suitably configured database with open source ClickStack or Self-managed ClickHouse Observability.
2. New Relic
As a long-standing leader in the APM space, New Relic offers a mature, all-in-one observability platform. It combines application, infrastructure, browser, and log monitoring into a single solution, providing teams with a unified view of their entire stack.
- Key features: Comprehensive Application Performance Monitoring (APM 360), real-user monitoring (RUM), infrastructure monitoring, and an AI-powered alerting engine.
- Pros: Established, feature-rich platform praised for its powerful APM capabilities. The alerting system is considered accurate and reliable.
- Cons: High cost and a complex, user-based pricing model that penalizes growing teams. Some users also note challenges with dashboard configurations and Kubernetes integrations.
- Best for: Enterprise teams that require a mature, consolidated platform with deep APM insights and are less constrained by budget.
3. Dynatrace
Dynatrace is an enterprise-focused observability platform known for its powerful AI capabilities and automated full-stack monitoring. Its core strength lies in the "OneAgent" technology, a single agent deployment that automatically discovers and maps all components and dependencies.
- Key features: AI-powered engine (Davis), full-stack monitoring (RUM to code-level), automated topology mapping (Smartscape), and digital experience management.
- Pros: Strong automation and AI-driven root cause analysis simplify complex problem detection. The unified OneAgent simplifies deployment.
- Cons: High cost and complex pricing model. The "OneAgent" can be resource-intensive, and the platform has a steep learning curve.
- Best for: Large enterprises with complex, dynamic cloud environments that need powerful, AI-driven automation.
4. Grafana Stack (Loki, Mimir, Tempo)
The Grafana LGTM (Loki, Grafana, Tempo, Mimir) stack is a popular open-source observability solution made up of distinct, specialized components. Grafana serves as the central visualization platform.
- Key features: Loki (efficient log aggregation), Mimir (scalable metrics storage), Tempo (distributed tracing), and Grafana (visualization).
- Pros: Cost-effective label-based indexing, open-source flexibility, and a unified visualization interface.
- Cons: High operational complexity (managing multiple stateful systems), correlation happens at the application layer rather than the data layer, and data remains siloed.
- Best for: Teams already committed to the Prometheus/Grafana ecosystem who prefer self-hosted solutions and have the resources to handle complexity.
5. Splunk
Splunk is a powerful and long-standing platform known for its capabilities in searching, analyzing, and visualizing machine-generated data. It is a staple in many enterprise IT operations for log management and SIEM.
- Key features: Powerful Search Processing Language (SPL), real-time visibility, high scalability, and extensive integrations.
- Pros: Market leader in log management, strong security (SIEM) features, and highly customizable.
- Cons: Prohibitive cost at scale (especially for ingest-heavy workloads), poor query performance for complex analytics compared to columnar stores, and a steep learning curve.
- Best for: Large enterprises with significant budgets prioritizing deep log analysis and security use cases.
6. Chronosphere
Chronosphere is a cloud-native observability platform built for high-scale environments. It leverages the open-source M3 metrics engine to handle massive amounts of high-cardinality data.
- Key features: Control Plane (shape/filter data before storage), scalable Prometheus backend (M3 based), and distributed tracing integration.
- Pros: Effectively tames high cardinality via traffic shaping and offers cost predictability.
- Cons: Relies on data dropping/aggregation to control costs (losing fidelity), metrics-heavy heritage with less mature logging, and enterprise-focused pricing.
- Best for: Large, cloud-native organizations struggling with Prometheus scaling limits and needing strict control over metric growth.
7. Signoz
Signoz is an open-source APM and observability platform that positions itself as a direct, self-hostable alternative to Datadog. It is powered by Open Source ClickHouse.
- Key features: Unified UI (metrics, traces, logs), native OpenTelemetry support, and a ClickHouse backend.
- Pros: Open-source freedom (self-hostable), cost-effective compared to SaaS, and an all-in-one "Datadog-like" experience.
- Cons: Operational overhead for self-hosting and feature maturity compared to giants like New Relic. Critically, the self-hosted version lacks native separation of storage and compute. This results in three key inefficiencies: an inability to isolate read and write workloads, limitations on scaling to petabyte levels, and a lack of cost-efficient long-term retention on object storage.
- Best for: Engineering teams wanting a unified, open-source solution or needing to leverage ClickHouse's efficiency without building a UI.
8. Dash0
Dash0 is a newer entrant built on ClickHouse Open Source similar to Signoz. It positions itself as a serverless, OpenTelemetry-native observability data lake, focusing on "Observability as Code."
- Key features: Serverless architecture, dashboarding via Perses/Grafana, and direct OTel ingestion.
- Pros: Zero maintenance (no backend management), no indexing costs, and strong OTel alignment.
- Cons: Per-event pricing can punish verbosity during incidents, "headless" visualization creates a disjointed workflow, and the platform is still in early stages. Additionally, it shares the architectural limitations of standard open-source ClickHouse: lacking full separation of storage and compute and requiring data to be duplicated in object storage in order to scale compute beyond vertical limits. This design limits performance when querying older data stored in colder tiers for larger workloads.
- Best for: Teams fully committed to OpenTelemetry who want a low-ops, serverless backend and are comfortable building their own visualizations.
Comparison summary table: finding the right fit
| Alternative | Pricing model | Architecture | Instrumentation & OTel | Best for high cardinality? | Unified datastore? | Cost at scale |
|---|---|---|---|---|---|---|
| ClickHouse Observability | Ingested GB for logs and traces; metric data points | Unified columnar database | Native OTel (schema designed for OTel) | Yes, natively | Yes (logs, metrics, traces) | Very low & predictable |
| New Relic | User-based, ingest-based | Proprietary SaaS | Full OTel support; proprietary agent optional | No, can be costly | Yes | High |
| Dynatrace | Host-based / "Davis Data Units" | Proprietary SaaS / OneAgent | OTel compatible; OneAgent required for AI | No, can be costly | Yes | Very high |
| Grafana | Resource-based (self-hosted) | Siloed (Loki, Mimir, Tempo) | Prometheus & OTel native | Yes, but complex | No (separate backends) | Low (high ops cost) |
| Splunk | Ingest-based / "Splunk units" | Search index | OTel for APM; proprietary for logs | No, struggles at scale | Primarily logs/SIEM | Very high |
| Chronosphere | Usage-based / shaped | Cloud-native SaaS (M3) | OTel compatible; Prometheus native | Yes, via control plane | Primarily metrics/traces | High (enterprise) |
| Signoz | Usage-based / Free OSS | OSS ClickHouse | Native OTel | Yes, natively | Yes | Moderate (No cost-efficient long-term retention) |
| Dash0 | Usage-based | Serverless OTel Data Lake on OSS ClickHouse | Native OTel | Yes | Yes | Moderate (No cost-efficient long-term retention) |
Conclusion
The search for a Datadog alternative often begins with sticker shock, but the real solution is found in architecture. As data volumes and cardinality continue to explode, platforms built on a search index or siloed backends will inevitably pass their scaling costs on to you. The key advantage of a unified, columnar data engine is that it treats massive-scale analytics as a native feature, not a billing problem. ClickHouse Observability, powered by ClickHouse, represents this modern approach, offering a path to deep, powerful observability without the false choice between cost and comprehensive visibility.
Ready to see what performance at scale feels like? Explore ClickHouse Observability, or read our case study to see how high-volume teams are reducing costs by moving to a columnar engine.
Frequently asked questions
The most cost-effective alternative depends on the workload. ClickHouse Observability, powered by ClickHouse and open source ClickStack, uses compression and efficient queries to support affordable retention. Logs and traces are priced by ingested GB, and metrics by data points. The historical internal ClickHouse comparison reporting up to 200x savings is not a price or guarantee for this service. SigNoz remains another option to evaluate; compare costs using your own volume, retention, and query needs.
Platforms with a flexible, open architecture are ideal for this. Open source ClickStack, for instance, is OpenTelemetry-native but is designed to integrate data from any source. You can use agents like Vector to transform and ingest data from other proprietary sources, creating a unified telemetry stream without being locked into one standard. For the turnkey alternative, ClickHouse Observability receives OpenTelemetry through a managed endpoint and operates the backend for you.