Moving to ClickHouse meant 70 percent lower costs and a 10x improvement in search performance. With amazing out of the box performance and really amazing compression, we got the ingest performance we needed and the headroom to make queries fast. We're doing more and storing more with less.
- Comparisons
- Observability
ClickStack vs OpenSearch

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.
OpenSearch, derived from Elasticsearch, remains anchored in a search-first architecture built on inverted indices. While effective for text search, this design falls short for modern observability workloads: it drives high disk usage, yields poor compression, and slows down queries at petabyte scale. Logs, metrics, and traces necessarily sit in separate indices, with no native way to join or analyze them together.
Why ClickStack is better than Lucene-based observability:
4x
Reduction in costs
10x
Faster analytical queries
2x
Better compression
Frustrated by slow queries, rising storage costs, and an endless need to scale horizontally? You’re not alone.
Join Canva in migrating from OpenSearch
Why ClickStack outperforms OpenSearch Observability
Performance at scale
OpenSearch 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. OpenSearch was never designed for analytical workloads leaving data fragmented.
Operational simplicity
ClickStack eliminates the overhead of managing tens, hundreds, or even thousands of shards and the constant JVM tuning that comes with them. Its optimized engine scales vertically, handling massive datasets within a single shard - only requiring sharding at extreme volumes - reducing network overhead and costly rebalances.
ClickStack compared to OpenSearch for Observability
At a high level, OpenSearch and ClickStack share a familiar shape: both have a data collection layer (FluentBit and Data Prepper vs. OpenTelemetry), a storage engine (OpenSearch vs. ClickHouse), and a UI (OpenSearch dashboards vs. HyperDX). But beneath these parallels, the architectures diverge.
How do the OpenSearch and ClickStack architectures differ?
As a fork of Elasticsearch, OpenSearch 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
Aggregate states for accuracy
- Yes
Native object storage support
- 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
Decoupled compute/storage (ClickHouse Cloud)
- Yes
Stateless compute nodes (ClickHouse Cloud)
- Yes
Lucene style search via HyperDX
- Yes
Self-managed & 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
Terms aggregations are estimates and have slower performance
- Intermediate—
Remote backed storage supported for replicas only. S3-backed warm storage at lower performance.
- Intermediate—
Doc values provide columnar storage, not compressed
- Intermediate—
Requires Data Prepper/third parties or OpenSearch Ingestion Service for AWS managed instances
- Intermediate—
First event field determines type, no type preservation
- Intermediate—
Requires horizontal scaling/replicas
- Intermediate—
Limited with accuracy implications for terms aggregations; concurrent segment
- Intermediate—
Limited Join support
- Intermediate—
Limited incremental support; rollups and transforms typically rescan or aggregate large index segments per execution. Star-tree indexes precompute aggregates but support a narrow range of functions and filters.
- Intermediate—
Limited syntax coverage
- Intermediate—
AWS Serverless achieves partial decoupling via OCUs. Decoupling read/write paths comes at a high read/write latency (10s)
- Intermediate—
AWS OpenSearch Serverless only but compute does not idle. OCUs added in fixed increments depending on data volume.
- Yes
Lucene search supported
- Yes
Self-managed & AWS OpenSearch + third party providers
- Yes
Real-time ingest supported
- Yes
Inserts supported
- Yes
Inverted index supported
- Yes
REST API supported
- Yes
Ingest pipelines and AWS OpenSearch Ingestion Service for AWS instances
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
Cloud-agnostic and open
Deploy on any cloud or on-premises. ClickStack’s open architecture avoids vendor lock-in and integrates seamlessly across ecosystems.
Migrate your workload from OpenSearch 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, OpenSearch Observability and ClickStack share a familiar shape: both include a data collection layer (Data Prepper and Fluent Bit vs. OpenTelemetry), a storage engine (OpenSearch vs. ClickHouse), and a UI (OpenSearch Dashboards vs. HyperDX). But beneath these similarities, the architectures diverge.
OpenSearch is based on the distributed search engine originally derived from Elasticsearch, 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 supporting 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.
OpenSearch’s inverted-index architecture was designed for 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 10× faster queries and more precise aggregations for high-cardinality data, while also supporting inverted indices for fast text search on specific columns when 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 lower operational overhead. Users such as Netflix, Shopee, and Didi have reported 50%+ storage reduction and major savings compared to traditional Lucene-based observability stacks.
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 - 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.
OpenSearch’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 OpenSearch’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 any 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 and 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 (Helm charts) and in ClickHouse Cloud with managed scaling and storage separation.
In short, ClickHouse is the engine while ClickStack is the complete, ready-to-deploy stack built on top of it.
Yes. ClickStack is fully cloud-agnostic and can run in ClickHouse Cloud, on-premises, or in any cloud provider environment. Its open architecture and use of open standards, such as OpenTelemetry and open table formats, ensure full portability without vendor lock-in.
OpenSearch is also open source and can be deployed anywhere, but its managed service, Amazon OpenSearch Service, is tightly integrated with AWS infrastructure and APIs. While convenient for AWS users, this coupling can make cross-cloud or hybrid deployments more complex. ClickStack provides the same managed experience while remaining independent of any specific cloud provider.