Extensive testing and comparison showed that ClickHouse outperformed other solutions like Elasticsearch in three key areas: performance, compatibility, and cost-efficiency for large-scale operations.
- Comparisons
- Observability
ClickStack vs Elastic Observability

ClickStack is a high-performance, open-source observability stack built on ClickHouse. It delivers high compression, lightning-fast queries and powerful aggregations across high cardinality logs, metrics, traces, session replays at petabyte scale.
Elastic Observability, by contrast, is rooted in a full-text search engine, built on the belief that observability was just a search problem at a time when inverted indices were sufficient at smaller scales. Never designed for metrics, it cannot unify logs, metrics, and traces in a single system, leaving observability fragmented, costly, and slow.
Why ClickStack is better:
4x
Reduction in costs
10x
Faster analytical queries
3x
Better compression
Read our comprehensive guide about migrating from Elastic Observability to ClickStack.
Frustrated by slow queries, rising storage costs and an endless need to scale horizontally? You’re not alone.
Join others migrating to ClickStack from Elastic
Why ClickStack outperforms Elastic Observability
Performance at Scale
Elastic slows under heavy ingest and high-cardinality queries, while ClickHouse powers sub-second analytics even at petabyte scale.
Lower Cost, Higher Efficiency
ClickHouse’s columnar storage and advanced compression cut storage needs by > 50%, reducing infrastructure costs dramatically and allowing for long term retention.
Unified Observability
ClickStack runs logs, metrics, and traces in one engine alongside business and application data for unrivalled correlation. Elastic was never designed for analytical workloads leaving data fragmented.
Open source and open standards
ClickStack is fully open source (MIT + Apache 2.0) and OpenTelemetry-native, ensuring interoperability and freedom from lock-in.
ClickStack compared to Elastic Observability
At a high level, Elastic Observability (formally the ELK stack) and ClickStack share a familiar shape: both have a data collection layer (Beats and Logstash vs. OpenTelemetry), a storage engine (Elasticsearch vs. ClickHouse), and a UI (Kibana vs. HyperDX). But beneath these parallels, the architectures diverge.
How do the Elastic Observability and ClickStack architectures differ?
Elasticsearch is a distributed search engine built around inverted indices and a shard-based architecture. While effective for full-text search, this design introduces high storage overhead, limited query parallelization, and heavy contention between ingest and query workloads.
ClickStack is powered by ClickHouse, a database built on a columnar, shared-nothing architecture optimized for analytics. It minimizes storage with advanced compression, parallelizes queries across all available cores, and separates storage from compute in the cloud to deliver fast, efficient observability at scale. Full SQL support unlocks deep data analysis.
- Yes
Native object storage support
- Yes
Aggregate states for accuracy
- Yes
Columnar storage with high compression
- Yes
ClickPipes for streaming ingest
- Yes
JSON with type fidelity
- Yes
1,000+ QPS per node
- Yes
Full parallelization within & across shards
- Yes
Full join support
- Yes
Materialized views (incremental & refreshable)
- Yes
Full SQL support
- Yes
Lucene style search via HyperDX
- Yes
Self-managed & cloud
- Yes
Decoupled compute/storage (ClickHouse Cloud)
- Yes
Stateless compute nodes (ClickHouse Cloud)
- Yes
Real-time ingest supported
- Yes
Async inserts for small batches
- Yes
Inverted index support
- Yes
REST API support
- Yes
Incremental materialized views
- No
Paid, Elastic Cloud Serverless only
- No
Terms aggregations are estimates
- Intermediate—
Doc values provide columnar storage, not compressed
- Intermediate—
Requires Logstash/third parties, no hosted ingestion
- Intermediate—
First event field determines type
- Intermediate—
Requires horizontal scaling/replicas
- Intermediate—
Limited with accuracy implications for terms aggregations; concurrent segment
- Intermediate—
LOOKUP JOIN only
- Intermediate—
Limited types; requires full scans
- Intermediate—
Limited syntax coverage
- Yes
Lucene search supported
- Yes
Self-managed & Elastic Cloud
- Yes
Elastic Cloud Serverless
- Yes
Elastic Cloud Serverless
- Yes
Real-time ingest supported
- Yes
Inserts supported
- Yes
Inverted index supported
- Yes
REST API supported
- Yes
Ingest pipelines
Lower costs
10x cost savings thanks to high compression and resource efficiency
Simpler at scale
Homogenous architecture and vertical scaling simplifies and reduces nodes
Built for high cardinality analytics
Column orientation designed for high cardinality queries
Open and interoperable
Supports open standards like OpenTelemetry and integrates directly with systems and formats such as Postgres, Kafka, Parquet, and Iceberg.
Migrate your workload from Elastic Observability today
Cut costs, boost performance, and unlock observability at scale with ClickHouse.
FAQs
We're here to make observability simple, fast, and open. Explore our FAQs to learn more about ClickStack, and if you don’t see what you need, we’re always happy to chat.
ClickStack is a high-performance, open-source observability stack powered by ClickHouse. It unifies logs, metrics, traces and session replays, delivering lightning-fast queries and efficient storage at any scale.
At a high level, Elastic Observability(formally the ELK Stack) and ClickStack share a familiar shape: both have a data collection layer (Beats and Logstash vs. OpenTelemetry), a storage engine (Elasticsearch vs. ClickHouse), and a UI (Kibana vs. HyperDX). But beneath these parallels, the architectures diverge.
Elastic Observability is based on the distributed search engine Elasticsearch, which is built around inverted indices and a shard-based architecture. While effective for full-text search, this design introduces high storage overhead, limited query parallelization, and contention between ingest and query workloads.
ClickStack, powered by ClickHouse, takes a different approach. Its columnar, shared-nothing architecture is optimized for analytics, minimizing storage with advanced compression, parallelizing queries across all available cores, and separating storage from compute in the cloud for consistent, efficient performance. With full SQL support, ClickStack enables deep, real-time analysis across all your observability data while still providing support for Lucene-style queries for fast searching.
The ClickStack consists of three core components:
- ClickHouse - The columnar database powering fast, cost-efficient queries and compression.
- HyperDX - The unified UI for search, dashboards, alerts, and session replays.
- OpenTelemetry - Standardized data collection for logs, metrics, and traces.
Together, they form a single, integrated observability stack optimized for speed, scalability, and simplicity.
Elastic’s inverted index architecture was designed for text search, not analytics. As data volumes grow, aggregations become slow and memory-intensive - especially for high-cardinality fields. ClickStack uses ClickHouse’s columnar, vectorized engine to parallelize queries across all CPU cores, achieving sub-second analytics at petabyte scale. This typically results in 10x faster queries and more precise aggregations for high-cardinality data, while also supporting inverted indices for fast text search on specific columns if needed.
ClickStack reduces infrastructure costs by up to 4x through advanced compression and efficient resource utilization. Its columnar design requires less hardware and storage, while decoupled compute and storage in ClickHouse Cloud lowers operational overhead. Users like Netflix, Shopee, and Didi have reported 50%+ storage reduction and major savings compared to Elastic Observability.
Yes. ClickStack is a full observability platform designed to handle logs, traces and metrics in one place. Built on ClickHouse, it efficiently ingests and stores high-cardinality OpenTelemetry data, automatically correlating events at the database layer for deep, real-time insights.
Yes. ClickStack is built for OpenTelemetry at any scale. It includes a bundled OpenTelemetry Collector and natively ingests OTel events - combining logs, metrics, and traces into a unified model. Powered by ClickHouse’s parallel processing and columnar storage, ClickStack scales seamlessly from small deployments to petabytes of telemetry data while maintaining real-time performance.
Although ClickStack is OpenTelemetry-native, it also supports any wide event format. While OpenTelemetry schemas are provided out of the box, users can bring their own - just include a timestamp, and the HyperDX UI with ClickHouse delivers the same powerful querying, correlation, and visualization capabilities.
No. While ClickStack is optimized for the OpenTelemetry schema, making it the fastest way to get started and scale easily, it’s not limited to it. ClickHouse, the database powering ClickStack, can store and query any event schema.
The HyperDX UI requires only a timestamp field to render and visualize events, so you can use your own data formats or custom pipelines. By following a wide events pattern and including a timestamp, your data becomes immediately usable within ClickStack.
Elastic Observability’s scalability is limited by its shard-based architecture and JVM heap constraints, which cap shard sizes and force horizontal sprawl as data grows. Queries only parallelize within shard boundaries, and node failures often trigger costly rebalances and performance degradation.
ClickStack, powered by ClickHouse, scales vertically and horizontally without these limits. It supports unlimited shard sizes, executes queries in parallel across all cores and replicas, and separates compute from storage for elastic scaling in the cloud. In ClickHouse Cloud, multiple compute warehouses can share the same data in S3, enabling read/write isolation, independent scaling, and cost-efficient long-term retention.
In short, ClickStack scales to petabytes with consistent performance, while Elastic’s architecture struggles beyond terabyte-scale workloads.
Yes. ClickStack and its components are fully open source and built on open standards. ClickHouse and the OpenTelemetry collector are licensed under Apache 2.0, with the HyperDX UI using the MIT license. You can deploy ClickStack anywhere - self-hosted, hybrid, or in the cloud, without restrictions.
Yes. ClickStack is available as a managed service in ClickHouse Cloud. It delivers the same open architecture with elastic scaling and full separation of storage and compute, allowing users to scale resources independently and isolate read and write workloads for consistent performance.
With advanced compression and cost-efficient object storage, data can be retained indefinitely at low cost. ClickHouse Cloud also includes automatic backups and zero operational overhead. The HyperDX UI is fully integrated - available at no additional cost, secured through ClickHouse Cloud authentication, and can be launched on any service.
A fully managed ClickStack offering is also planned for the future.
ClickStack is built on ClickHouse but extends it into a full observability platform. While ClickHouse is the high-performance analytical database at its core, ClickStack adds the surrounding ecosystem:
- Data collection: OpenTelemetry-native ingestion.
- Visualization: The HyperDX UI for log exploration, traces, and dashboards.
- Prebuilt schema and integrations: Optimized ClickHouse table engines, views, and storage models for observability data.
- Deployment options: Available as both open-source, with helm charts, and ClickHouse Cloud offerings with managed scaling and storage separation.
In short, ClickHouse is the engine - ClickStack is the complete, ready-to-deploy stack built on top of it.