Akshay Nanavati and Poom Chiarawongse, Members of Technical Staff at OpenAI, share how the OpenAI observability team scaled ClickHouse as ChatGPT adoption, and log volume, skyrocketed.

Session recording from Open House, the ClickHouse user conference.

[https://clickhouse.com/openhouse](https://clickhouse.com/openhouse)

Scaling ClickHouse to petabytes of logs at OpenAI

Maruth Goyal, Member of Technical Staff at Anthropic, shares how ClickHouse is used to improve observability.

Session recording from Open House 2025, the ClickHouse user conference.

[https://clickhouse.com/openhouse](https://clickhouse.com/openhouse)

How ClickHouse helps Anthropic scale observability

Salim Syed, VP, Head of Engineering and Syd Mehmood, Director of Software Engineering at Capital One Slingshot share how they cut infrastructure costs by 50% and reduced average dashboard load time from 5+ to under 500ms with ClickHouse Cloud.

Session recording from Open House roadshow NYC 2025.

https://clickhouse.com/openhouse/nyc

Engineering leaders at Capital One share how they cut infrastructure costs by 50% and reduced average dashboard load time from 5+ to under 500ms with ClickHouse Cloud.

How Capital One cut infrastructure costs by 50%

Alon Tal, Senior Staff Software Engineer at Tesla, talks about Comet, Tesla's internal system built with ClickHouse for ingesting, storing and querying metrics at massive scale.

Session recording from Open House, the ClickHouse user conference.

[https://clickhouse.com/openhouse](https://clickhouse.com/openhouse)

Tesla-scale metrics with ClickHouse

A walk through of Managed ClickStack end to end: what it is, why we built it, and how it changes the economics of observability.

Managed ClickStack: Live Demo

**Interviewer:** Zoe Steinkamp, Developer Advocate, ClickHouse 
<br />
**Guest:** Haroen Vermylen, Co-Founder & CTO, Luzmo

---

**What does Luzmo do?**

Luzmo is an embedded analytics platform. We offer reports, data visualization, conversational analytics, and dashboards that our clients — typically software companies — can embed inside their products to give their customers insights into all the data that's been captured on them.

**Can you give an example of a customer?**

We have clients across a wide variety of sectors. A typical SaaS use case is Selegens, a marketing analytics platform powering ROI dashboards and campaign impact reports inside their Marketing Cloud. An entirely different sector is Proximus, the largest Belgian telecom provider, who use Luzmo to visualize location intelligence data — anonymized movement data inside Belgium — and monetize it. All the user interfaces and reports are built on Luzmo.

**Where does ClickHouse fit in?**

We first discovered ClickHouse in 2017 — it's been eight years now, and ClickHouse has been quite infectious inside our company. We started with it as our internal warehouse for storing data that customers share with us. We're a federated platform — not all client data lives on our platform, but some clients want us to be responsible for storing it. We want to make it fast for them, which is why we settled on ClickHouse.

**When did you move from open source to Cloud?**

Quite quickly after it became generally available — 2022, I believe.

**What made you switch?**

Running clusters isn't our core business. We're in the business of building analytics and reporting, so that was a task we wanted to get rid of. ClickHouse Cloud seemed like the right offering to make that happen.

**Did Cloud enable wider adoption internally?**

Definitely. We're now also storing our query logs and plugin logs on ClickHouse — more of an observability use case. Within our platform, our software customers can review what queries are happening, identify slow queries, and trace which data source on their side is causing the issue. At which point we advise them to switch to ClickHouse.

**Most exciting features in the past year or two?**

I'm generally quite impressed with ClickHouse's speed of execution and interest in non-obvious use cases. Things like ANOVA tables available out of the box — I've never seen that in another database. More recently, we've started using ClickHouse as a vector database for storing embeddings of metadata and data. It's already there, it makes sense, and the implementation is quite good.

**What made ClickHouse stand out when you first evaluated it?**

We evaluated a number of players at the time, but ClickHouse was doing things differently. The big talk back then was distributed systems — you can handle big workloads but you need 100 servers, which isn't cost-effective and adds a lot of complexity. ClickHouse came out and it worked on my laptop. That was pretty amazing. The raw performance increase it gave for most of our workloads was the reason to keep following it.

**Any challenges on Cloud?**

A couple of gotchas, some of which have already been solved. Because we don't know our clients' data until we receive it, we have tens of thousands of different tables, and ClickHouse can sometimes struggle with that workload. We've also built our own query engine to efficiently optimize queries — ordering them correctly, pulling data from other systems in the best way. We can automatically group incoming queries and consolidate them into single operations, reducing pressure on ClickHouse. The new JSON data type is also very interesting — we're not using it to maximum effect yet, but we're watching it closely.

**Three words to describe ClickHouse?**

Extremely fast, extremely versatile, extremely cost-efficient.


"Extremely Fast, Extremely Versatile, Extremely Cost-Efficient" — Luzmo's 8-Year ClickHouse Journey

Parsing dates and datetimes is one of those things you'll do constantly in ClickHouse, and there are actually quite a few different approaches depending on your data format. In this tutorial, we walk through five practical methods for handling everything from Unix timestamps to
 messy string formats that you might get from APIs or legacy systems.

  * Converting Unix timestamps (seconds, milliseconds, and microseconds)
  * Parsing numeric date formats from legacy databases and mainframes
  * Handling datetime strings with known formats using MySQL and JODA syntax
  * Using "best effort" parsing for inconsistent or unknown date formats
  * Configuring session-level settings for automatic type casting can we make this to htnml

Parsing dates and datetimes in ClickHouse

Comparing cloud data warehouse costs is harder than it looks. Different platforms meter, scale, and bill compute in fundamentally different ways, which makes price lists misleading. Instead of arguing about list prices or pricing tiers, this webinar shows that efficiency is the real currency.

Tom Schreiber and Lio Palacin break down how Snowflake, Databricks, ClickHouse Cloud, BigQuery, and Redshift charge for compute, then share benchmark results at 1B, 10B, and 100B rows using our reproducible Bench2Cost method to translate runtimes into real dollars. 

This presentation offers a clear way to evaluate cost and performance as your data scales.

Breakdown of how the 5 major data warehouses charge for compute and benchmarked results at 1B, 10B, and 100B rows.

The True Cost of Speed: What Query Performance Really Costs at Scale

Arrow Flight is a high-performance RPC framework built on gRPC that's specifically designed for efficiently transferring large Arrow datasets between services. In this hands-on tutorial, we explore how to use ClickHouse as an Arrow Flight server, demonstrating both bulk data retrieval and streaming approaches. We'll work with a real dataset of over 30 million UK property records to show you the practical performance characteristics and capabilities you can expect.

The video walks through three different approaches to querying data via Arrow Flight. First, we look at a simple bulk query that retrieves all 30 million rows in one go, which takes around 7-9 seconds. Then we explore streaming the data in batches, which improves performance to about 4.7 million rows per second and completes in roughly 6.5 seconds. Finally, we demonstrate how to compute aggregates on-the-fly while streaming, calculating running statistics like average and maximum property prices as the data flows through.

Key Learning Points:
* Setting up ClickHouse as an Arrow Flight server with basic configuration
* Connecting to ClickHouse using the Arrow Flight client protocol
* Bulk data retrieval vs. streaming approaches and their performance trade-offs
* Working with Arrow Flight metadata and endpoints for distributed queries
* Computing real-time aggregates during streaming without significant performance impact
* Practical performance benchmarks with a 30+ million row dataset

ClickHouse as an Arrow Flight Server

The ClickHouse v26.1 release brings 25 features, 43 performance optimizations, and 176 bug fixes. Alexey walks through the technical updates - distinct queries are now 2x faster on low-cardinality columns, JIT compilation extends to nullable aggregates and decimals, and sparse n-grams improve text search selectivity. There's also a new Keeper dashboard that exposes cluster metrics and node data over HTTP, plus better async insert idempotency that now covers materialized views.

The bigger announcement is ClickHouse's managed Postgres service, now in private preview. It's purpose-built for teams running Postgres and ClickHouse together, offering native CDC replication and the PG-ClickHouse extension for querying ClickHouse through Postgres. The goal is to collapse the integration timeline from months to days, with minimal application changes. Sai demos the full flow—creating a Postgres instance, replicating to ClickHouse, and running analytical queries that are 5x faster than OLTP.

This session covers:
- System table additions, reverse-by-separator function, and projection syntax updates
- Max-min fair scheduler for more consistent query latencies under concurrency
- Data lake support for Paimon, Delta Lake deletions, and GCS
- Live Postgres demo with performance comparisons and query pushdown details
- Open source updates—Kubernetes operator, CHDB Pandas API, LangFuse acquisition

ClickHouse v26.1 Release Webinar

Looking to speed up your vector similarity searches in ClickHouse? This video walks through approximate vector search using HNSW indexes, which can dramatically reduce query times compared to linear scans. We'll work with a dataset of nearly a million Wikipedia entries, showing you how to set up vector similarity indexes and when to use different distance functions.

We start with a basic linear scan approach using L2 distance, then introduce vector similarity indexes that bring query times down from seconds to milliseconds. You'll see practical examples using both L2 and cosine distance functions, and learn when each one makes sense for your data. We also cover filtering strategies—pre-filter versus post-filter—and how ClickHouse's query engine decides which approach to use based on heuristics.

* Setting up vector similarity indexes with HNSW on embedding columns
* Comparing L2 distance (Euclidean) vs cosine distance for similarity calculations
* Performance differences between linear scan and approximate search methods
* Adding WHERE conditions to vector searches and understanding filter strategies
* Controlling pre-filter vs post-filter behavior with vectorSearchFilterStrategy setting


Approx vector search in ClickHouse

This talk explores how organizations use ClickHouse Materialized Views and Dictionaries to transform, enrich, and aggregate streaming data on ingest, enabling high-performance personalization, operational dashboards, and anomaly detection while reducing ETL overhead and infrastructure costs.

Topics include:

- How Materialized Views simplify real-time pipelines by replacing complex ETL with ingest-time transformations.
- Understand how Dictionaries and multi-stage MV patterns enrich and aggregate streaming data for millisecond-speed analytics.
- Explore proven architectural approaches and best practices for building scalable, real-time applications on ClickHouse.
- Discover optimization strategies that lower infrastructure costs while accelerating time-to-insight for high-volume workloads.

Maruthi Lokanathan, Solution Architect at ClickHouse
Derek Chia, Principal TAM Architect at ClickHouse

Under-the-Hood: ClickHouse Incremental Materialized Views and Dictionaries

Looking to speed up your ClickHouse queries without doubling your storage costs? In this tutorial, we dive into lightweight projections, a feature introduced in ClickHouse 25.6 that gives you the performance benefits of secondary indices without the hefty storage overhead. 

Instead of duplicating entire tables as traditional projections do, lightweight projections only store the sort key columns plus an offset column that points back to the original data.

We'll walk through a practical comparison using 30 million rows of UK property sales data, testing three different approaches: no projections, traditional projections, and the new lightweight projections. The results are pretty interesting—lightweight projections deliver query speeds that are roughly 2x slower than full projections but use half the storage space, making them a solid middle ground when you need better query performance but can't afford to double your disk usage.

* Understanding how lightweight projections work with the offset column mechanism
* Hands-on setup and data insertion comparison across different projection types
* Real performance benchmarks: 131ms (no projection) vs 6ms (full projection) vs 13ms (lightweight projection)
* Storage trade-offs: balancing query speed against disk space requirements
* Practical guidance on when to use lightweight projections versus traditional ones

ビデオ