ClickHouse vs TimescaleDB in 2026: OLAP, TigerData & TCO
ClickHouse vs TimescaleDB (TigerData) in 2026, compared on engineering and 36-month TCO: MergeTree vectorized scans vs Hypercore under the TSL, no timescaledb extension on AWS RDS, PostgreSQL FORCE RLS plus ClickHouse ROW POLICY isolation, and the math at 78B events/mo.

On this page

If you're scaling customer-facing charts, financial audit feeds, or industrial telemetry past fifty million PostgreSQL rows, you end up at the ClickHouse vs TimescaleDB decision. In practice you're choosing a real time analytics database, and the shortlist is usually ClickHouse (self-hosted or ClickHouse Cloud), TimescaleDB from TigerData (Tiger Cloud), or plain PostgreSQL with DuckDB. On day 1, SELECT count(*), percentile_cont(0.95) ... GROUP BY 1 runs in 40 ms on RDS. Twelve months later fifty billion rows no longer fit in RAM, autovacuum pins IOPS, and dashboards time out at 12 seconds.
This guide covers one layer of the stack: the OLAP database or time series database that scans terabytes underneath everything else. For the layers around it, see Metabase vs Superset for embedded BI, Airbyte vs Fivetran for ELT and CDC ingestion, Dagster vs Prefect for orchestration, and Neon vs Supabase for OLTP Postgres.
At Idealogic, our custom software development, SaaS development, software development consulting, and product development teams build analytics backends for fintech, manufacturing, and logistics and supply chain clients. Here we compare ClickHouse, TimescaleDB (TigerData), and PG17 with Parquet, show a production pattern (PostgreSQL FORCE RLS buffer, ClickHouse ROW POLICY reads), and price it all over 36 months at 30,000 events/sec (78B events/mo, 18 TB compressed). PostgreSQL 18 has been out since late 2025. Nothing here depends on a 17-only feature, so read PG17 as 17 or newer.
The short version
- ClickHouse (Apache 2.0) is the faster scanner and the cheaper store. ClickHouse is a columnar OLAP database with vectorized SIMD execution, ZSTD and delta codecs (typically 10x or more on log and event data in our workloads), incremental
AggregatingMergeTreerollups, and S3 tiering in the open-source server. Run it with the Altinity Kubernetes Operator or on ClickHouse Cloud. - TimescaleDB (TigerData) is better at relational SQL joins, but its license limits where it runs. Timescale rebranded to TigerData in 2025. TimescaleDB is a PostgreSQL extension, so you keep full SQL and get hybrid row-columnar Hypercore compression. Compression and Continuous Aggregates sit under the Timescale License (TSL), native S3 tiering is a Tiger Cloud feature, and Amazon RDS and Aurora PostgreSQL don't offer the extension at all.
- Naive RDS Postgres gets expensive fast at 30k events/sec. Even 90 days of uncompressed, indexed tuples (25 TB) across Multi-AZ plus a reader costs $8,625/mo in RDS gp3 storage alone in our model. That pushes 3-year RDS TCO to $621,600.
- At 30k events/sec (18 TB compressed, 500 B2B tenants), owned ClickHouse has the lowest TCO. Over 36 months, owned Apache 2.0 ClickHouse on EKS with S3 costs $173,100 at CEE rates, against $318,900 for ClickHouse Cloud Enterprise, $372,000 for Tiger Cloud Enterprise, and $621,600 for naive RDS PG17. These are modeled figures.
ClickHouse vs TimescaleDB at a glance
- Pick ClickHouse for append-heavy events, scans over billions of rows, and many-tenant dashboards.
- Pick TimescaleDB when time-series data has to join live PostgreSQL tables with ACID updates and foreign keys.
- On AWS, TimescaleDB means Tiger Cloud or self-managed EC2/EKS, never RDS.
- Below about 3,000 events/sec, ClickHouse vs Postgres for analytics has a simple answer: stay on Postgres.
ClickHouse vs TimescaleDB storage internals and licensing: MergeTree vs Hypercore
ClickHouse is an open-source (Apache 2.0) columnar OLAP database. TimescaleDB, now developed by TigerData, is a PostgreSQL extension that turns Postgres into a time series database. So ClickHouse vs TimescaleDB (or TimescaleDB vs ClickHouse, if you're coming from Postgres) comes down to how your workload behaves: large immutable event scans, or mutable relational time series with live OLTP joins.
1. ClickHouse (Apache 2.0): sparse primary indexes, SIMD column scans and the micro-insert trap
ClickHouse is built for analytical SELECT throughput. Row-level OLTP writes are not what it's for.
- Sparse primary index and SIMD scans. ClickHouse sorts immutable column granules (8,192 rows by default) by the
ORDER BYkey. It keeps a compact sparse index in RAM and runs ZSTD and Delta-encoded columns through vectorized AVX-512 or NEON code paths. - Incremental materialized views (
AggregatingMergeTree). Inserts pre-aggregate into compact states (countState,sumState,quantilesTDigestState), so a 12-month p95 dashboard query over billions of events typically comes back in tens of milliseconds. - Operational rules:
Too many partsand mutations. Single-row inserts create parts faster than ClickHouse can merge them. Once a partition passesparts_to_throw_insert(3,000 by default in current versions), inserts fail withToo many parts. Send at least 1,000 rows per insert, ideally 10,000 or more, or turn onasync_insert=1. Handle late corrections withReplacingMergeTree(version), notALTER TABLE UPDATE.
2. TimescaleDB / TigerData (Apache 2.0 + TSL): Hypercore hybrid engine and the AWS RDS gap
Since the 2025 rebrand to TigerData, the product line is the TimescaleDB extension plus Tiger Cloud:
- Hypertables and Hypercore. TimescaleDB splits a Postgres table into time chunks (a hypertable). Hot chunks stay as uncompressed heap rows, with MVCC
INSERT/UPDATEand foreign keys. Older chunks convert into Hypercore columnar arrays withtenant_idmin/max skipping. TigerData cites compression of 90% or more on suitable workloads. That's a vendor figure, not a default. - Native PostgreSQL joins. Queries join hypertables directly against live
users,devices, orpgvectortables in one SQL planner. - The TSL and cloud-tiering split. In TimescaleDB 2.x, Hypercore compression, Continuous Aggregates, and job scheduling are under the Timescale License (TSL). You can self-host them for free on EC2 or EKS, but the license restricts third parties from offering them as a hosted database service. S3 object tiering is a Tiger Cloud feature. And neither Amazon RDS nor Aurora PostgreSQL lists
timescaledbamong its supported extensions, so on AWS you need Tiger Cloud or a self-managed install.
3. ClickHouse Cloud pricing vs self-hosted EKS and the PG17 + DuckDB cutoff
- ClickHouse Cloud pricing. ClickHouse Cloud (Basic, Scale, Enterprise) separates stateless compute replicas from shared, S3-backed
SharedMergeTreestorage, listed at about $25.30 per TB-month compressed (list price, varies by region). A B2B SaaS with 500 active tenants never goes idle, so auto-pause doesn't help, and Enterprise adds 3-AZ, PrivateLink, and HIPAA/PCI options. Compute ends up dominating the bill. Our model assumes about $0.39 per compute-unit-hour, which gives $8,200/mo against $2,850/mo self-hosted on EKS. Actual compute prices vary by tier and region. - The cutoff under 3,000 events/sec (PG17 + DuckDB). Below 3,000 events/sec (under 200 GB/mo compressed), skip the separate OLAP cluster. PostgreSQL declarative partitioning, minute rollup tables, and S3 Parquet cold archives queried with embedded DuckDB are enough.
The ingest and latency rows are illustrative ranges from our workloads, not benchmark results. Public benchmarks depend on query shape: ClickHouse leads the scan-heavy ClickBench, while TigerData's own RTABench puts TimescaleDB ahead on selective, join-heavy queries. We advise self-hosted TimescaleDB up to about 15k events/sec when relational joins are the point.
Multi-tenant ClickHouse blueprint: PostgreSQL RLS buffer, batched inserts and row policies
Two failure modes hurt multi-tenant ClickHouse rollouts behind customer-facing SaaS dashboards, data pipelines, and observability vs monitoring portals. Unbatched micro-inserts crash partitions with Too many parts. And a tenant ID pasted into a SQL string by the application is one bug away from showing one customer's revenue numbers to a competitor across multi-tenant SaaS boundaries.
The pattern we use handles both. Operational writes land in a partitioned PostgreSQL 17 buffer table protected by Row-Level Security with FORCE enabled. A flusher moves 5,000-row deduplicated batches into ClickHouse ReplacingMergeTree raw tables and AggregatingMergeTree minute rollups. Dashboards read through a ClickHouse row policy and parameterized views that run with SQL SECURITY INVOKER.
The read side is the part most teams get wrong. The dashboard role is read-only and allowed to change only the tenant setting. A row policy on the rollup table fails closed, so an empty or wrong SQL_tenant_id matches no rows. The app queries a parameterized view with SQL SECURITY INVOKER and passes typed tenant, metric, and time-range values, never SQL text.
The client sets SQL_tenant_id on every query and passes the same tenant as a view parameter. If the setting is missing, or doesn't match the parameter, the query returns zero rows instead of someone else's data. Self-hosted clusters have to allow the SQL_ prefix in the custom settings prefixes server config for this to work.
If a flusher pod retries before the buffer rows are marked as flushed, ReplacingMergeTree deduplicates raw drill-downs that read with FINAL, and the tenant-first sort key keeps that FINAL scan inside one tenant. Higher-throughput streams (30k+ events/sec) swap the Postgres buffer for Redpanda vs Kafka consumer batches.
ClickHouse vs TimescaleDB cost: worked 36-month TCO model at 30,000 events/sec
The model is a B2B customer-facing analytics product over 36 months:
- 30,000 events/sec sustained (77.76B, call it 78B events/mo), with 90k/sec peaks
- 18 TB/mo (18,000 GB/mo) of raw JSON, compressed 12x to 1.5 TB/mo. The 12x ratio is our assumption.
- A 12-month queryable window of 18 TB compressed: 3 TB hot on NVMe/gp3 for 60 days, 15 TB warm on S3 for the other 10 months
- 500 concurrent B2B customer tenants, with p95 under 120 ms
- Okta SAML SSO, SOC 2 Type II, and PCI DSS v4.0.1
Labor compares Idealogic's $75/hr senior CEE rate with a $165/hr US agency rate (2.2x). For context on that gap, see Eurostat's EU whole-economy hourly labour cost levels (lc_lci_lev) and the US DOL O*NET profile for Software Developers (15-1252.00). Infrastructure uses us-east-1 list prices: AWS EBS gp3 at $0.08/GB-mo, RDS gp3 at $0.115/GB-mo Single-AZ and $0.23/GB-mo Multi-AZ, and Amazon S3 at $0.023/GB-mo Standard and $0.0125/GB-mo Standard-IA. The managed-cloud and instance figures in the four options are our modeled assumptions, not vendor quotes.
- Option A: ClickHouse Cloud Enterprise (3-AZ HA, PrivateLink, SAML SSO, 18 TB compressed)
- Setup, 100h ($7,500 at $75/hr CEE; $16,500 at $165/hr US): Terraform PrivateLink,
SharedMergeTreerollups,ROW POLICYviews, and SAML SSO. - 36 months of cloud ($8,200/mo x 36 = $295,200, modeled): always-on 3-AZ Enterprise compute (24 units at an assumed $0.39/unit-hr = $6,833/mo), 18 TB of compressed storage ($455/mo), and PrivateLink and ingest transfer ($912/mo). Add 6h/mo (216h) of ops, $16,200 CEE or $35,640 US, for a total of $318,900 ($347,340 US).
- Setup, 100h ($7,500 at $75/hr CEE; $16,500 at $165/hr US): Terraform PrivateLink,
- Option B: TigerData (Tiger Cloud Enterprise with Hypercore, S3 tiering, HA replica)
- Setup, 100h ($7,500 CEE; $16,500 US): VPC PrivateLink, Hypercore compression policies, Continuous Aggregates, and SAML SSO.
- 36 months of managed cloud ($9,600/mo x 36 = $345,600, modeled): a 32 vCPU / 128 GB HA writer plus a dashboard read replica ($7,450/mo), then 3 TB of hot compressed and 15 TB of tiered object storage with the Enterprise SLA ($2,150/mo). Add 7h/mo (252h) of ops, $18,900 CEE or $41,580 US, for $372,000 ($403,680 US).
- Option C: Naive AWS RDS PostgreSQL 17 (db.r8g.8xlarge Multi-AZ, a reader, 25 TB of 90-day RDS gp3)
- Setup, 200h ($15,000 CEE; $33,000 US):
pg_partmanpartitions, read-replica routing, B-tree tuning, andautovacuumthrottling. - 36 months of RDS ($15,500/mo x 36 = $558,000, modeled): RDS has no columnar compression, so even 90 days of row tuples and B-trees take 25,000 GB. A full 12 months would run past the 64 TiB storage limit that applies to common RDS PostgreSQL configurations. At $0.345/GB-mo for Multi-AZ plus reader gp3, that's $8,625/mo, plus $475/mo of IOPS, so $9,100/mo of disk. Add the db.r8g.8xlarge Multi-AZ writer and reader ($5,450/mo on a 1-year RI), snapshots ($950/mo), and 18h/mo (648h) of DBA firefighting, $48,600 CEE or $106,920 US, for $621,600 ($697,920 US).
- Setup, 200h ($15,000 CEE; $33,000 US):
- Option D: Owned Apache 2.0 ClickHouse on AWS EKS (Altinity Operator, gp3/NVMe hot, S3-IA warm, PG17 control plane)
- Turnkey build, 580h ($43,500 CEE; $95,700 US): Altinity
ClickHouseInstallation(2 AZ-isolated replicas and a 3-node Keeper quorum), the hot NVMe to warm S3 storage policy,ReplicatedAggregatingMergeTreerollups,ROW POLICYandINVOKERviews, the bulk flusher, and an Okta SAML BFF. - 36 months of right-sized AWS ($2,850/mo x 36 = $102,600, modeled): 2x r8gd.4xlarge NVMe replicas, 3x t4g.medium Keepers, and EKS ($1,525/mo on a 1-year Savings Plan). Hot storage is 6,000 GB of gp3 (3 TB x 2 replicas, 60 days) at $0.08/GB-mo = $480/mo. Warm storage is 30,000 GB of S3 Standard-IA (15 TB x 2 replicas, 10 months,
allow_remote_fs_zero_copy_replication=0) at $0.0125/GB-mo = $375/mo, plus $35/mo of S3 API calls through a $0 Gateway Endpoint, so $410/mo. The Multi-AZ RDS PG17 control plane and network add $435/mo. With 10h/mo (360h) of SRE time, $27,000 CEE or $59,400 US, the total is $173,100 ($257,700 US).
- Turnkey build, 580h ($43,500 CEE; $95,700 US): Altinity
Sensitivity check: the cutoff under 3,000 events/sec and CapEx payback
- Below 3,000 ev/s (under 200 GB/mo compressed): skip ClickHouse. Run PG17 partitions, minute rollups, and S3 Parquet with DuckDB (about $180/mo RDS delta, $9,000 sprint).
- 3k to 15k ev/s with relational SQL joins: self-host TimescaleDB on EC2 or EKS with Hypercore. The TSL allows that for internal use. RDS isn't an option, because it doesn't offer the extension.
- Payback at 30,000 ev/s ($75/hr CEE): Option D OpEx is $3,600/mo ($2,850 AWS + $750 SRE), against $8,650/mo for ClickHouse Cloud, $10,125/mo for Tiger Cloud, and $16,850/mo for naive RDS. The extra CapEx pays back in 7.13 months vs ClickHouse Cloud ($36,000 / $5,050/mo), 5.52 months vs Tiger Cloud ($36,000 / $6,525/mo), and 2.15 months vs naive RDS ($28,500 / $13,250/mo).
One caveat: Option D assumes someone on your team can own a Kubernetes cluster. If not, compare the managed options.
Real-time analytics database build costs in 2026 (senior CEE vs US)
Our custom software development, SaaS development, and software development consulting teams build OLAP platforms on fixed milestones at $75/hr senior CEE rates, against $165/hr at US agencies (2.2x):
Inside the worked 580-hour owned ClickHouse build ($43,500 CEE vs $95,700 US)
- 1. Altinity Operator and S3 tier (25% / 145h / $10,875 CEE vs $23,925 US): EKS r8gd NVMe nodes, 3 Keepers, the hot NVMe to warm S3 storage policy, S3 Gateway Endpoint, and
clickhouse-backup. - 2.
MergeTreeand rollup MVs (25% / 145h / $10,875 CEE vs $23,925 US): sparseORDER BYtuning,GorillaandZSTDcodecs,ReplacingMergeTree, andAggregatingMergeTree1m/1h MVs. - 3. PG17 / stream bulk flusher (20% / 116h / $8,700 CEE vs $19,140 US): a partitioned PostgreSQL buffer table, a 5,000-row
JSONEachRowbatcher, and a replay CLI. - 4.
ROW POLICYand query API (20% / 116h / $8,700 CEE vs $19,140 US):SQL_tenant_idfail-closed policies,INVOKERviews, a@clickhouse/clientBFF, and Okta SAML scopes. - 5. Chaos and cutover (10% / 58h / $4,350 CEE vs $9,570 US): 90k ev/s burst QA, 500-tenant
k6benchmarks, Parquet backfill, and parity checks.
Teams try to scale B2B analytics by throwing bigger RDS instances at twenty-five-terabyte B-trees, or migrate to ClickHouse and accidentally leak cross-tenant rows via string-interpolated filters. Ordering MergeTree tables by tenant_id, tiering warm parts to S3, and locking reads behind ClickHouse ROW POLICY cuts latency below eighty milliseconds at a quarter of managed cloud cost.
How to choose between ClickHouse and TimescaleDB: 5-step checklist
Idealogic's shipped work in this area:
- Market and ledger analytics (Bitholder and Fese): sub-second OHLCV rollups and risk analytics under PCI DSS v4.0.1.
- Fleet telemetry (HaulBreeze): GPS and cold-chain aggregation for logistics and supply chain SLAs.
- Industrial traceability (Airpart Chain): lifecycle audit telemetry across manufacturing (smart factory architecture).
Five checks settle ClickHouse vs TimescaleDB (TigerData) vs PG17 in 2026:
- Under 3,000 ev/s (under 200 GB/mo compressed)? Stay on PostgreSQL partitions, rollups, and S3 Parquet with DuckDB.
- 3k to 15k ev/s with OLTP SQL joins? Run Tiger Cloud, or self-host TimescaleDB with Hypercore on EC2/EKS. RDS doesn't offer the extension.
- Bursty traffic with idle auto-pause? Pick ClickHouse Cloud Scale.
- 24/7 enterprise SLA and no Kubernetes SREs? Negotiate ClickHouse Cloud Enterprise or Tiger Cloud Enterprise.
- 15k to 500k+ ev/s across 100+ tenants, and you want Apache 2.0 with the lowest TCO? Deploy owned ClickHouse on EKS (Altinity, gp3/NVMe, S3-IA,
ROW POLICY). Contact our team for a 48-hour OLAP audit.
Still split on ClickHouse vs TimescaleDB? If your dashboards join live Postgres tables, start with TimescaleDB. If they mostly scan events, start with ClickHouse.

CTO and Co-founder at Idealogic. Directing engineering, systems architecture, security, and full-stack delivery across web, mobile, and blockchain.
Frequently asked questions
Choose ClickHouse when you ingest tens of thousands to millions of append-heavy events per second, serve customer-facing dashboards over billions of rows with latency under 100 ms, or want Apache 2.0 self-hosting on Kubernetes with S3 tiered storage. Choose TimescaleDB (developed by TigerData) when your analytics have to join live relational PostgreSQL tables in the same SQL, or depend on ACID row-level updates and foreign keys. In our experience that fits best while ingest stays under roughly 15,000 inserts per second.
Yes. In 2025 the company behind TimescaleDB rebranded to TigerData and now runs its managed service as Tiger Cloud, a name meant to cover transactional, analytical, and AI workloads on PostgreSQL. Hypercore is TimescaleDB's hybrid row-columnar storage engine. It keeps recent hypertable chunks in row format for fast ACID writes and converts older chunks into compressed columnar arrays. TigerData cites storage reductions of 90% or more on suitable workloads, which is a vendor figure and not a guarantee.
No. Amazon RDS and Aurora PostgreSQL don't list timescaledb among their supported extensions, so you can't create hypertables there, let alone use compression or Continuous Aggregates. Licensing is part of the reason. TimescaleDB 2.x splits its code between an Apache 2.0 core and Community features under the source-available Timescale License (TSL), which restricts third parties from offering those features as a hosted database service. Hypercore columnar compression and Continuous Aggregates sit under the TSL, and native S3 tiering is a Tiger Cloud feature. On AWS your options are Tiger Cloud or self-managed TimescaleDB on EC2 or EKS.
ClickHouse writes every INSERT as a new immutable part on disk and merges parts in the background. Thousands of single-row, OLTP-style inserts per second outrun those merges, and ClickHouse rejects further inserts with Too many parts once a partition passes the parts_to_throw_insert limit (3,000 active parts by default in current versions). Fix it by batching at least 1,000 rows per insert, ideally 10,000 or more, from a PostgreSQL or Kafka buffer, or by enabling async_insert=1 so ClickHouse buffers small inserts in memory.
ClickHouse is built for immutable appends, where PostgreSQL uses heap tuples with MVCC. Frequent ALTER TABLE UPDATE or DELETE mutations rewrite whole multi-gigabyte data parts and starve disk I/O. For idempotent upserts and late corrections, production schemas use ReplacingMergeTree(version) or CollapsingMergeTree, paired with AggregatingMergeTree rollups and scoped FINAL queries.
Isolate tenants with row policies and parameterized views, not application WHERE clauses, and never interpolate tenant IDs into SQL strings. Put tenant_id first in the MergeTree sorting key. Give dashboards a read-only role (readonly = 1, SQL_tenant_id = '' CHANGEABLE_IN_READONLY). Attach a fail-closed CREATE ROW POLICY that filters tenant_id = toUUIDOrZero(getSettingOrDefault('SQL_tenant_id', '')), and expose queries only through parameterized SQL SECURITY INVOKER views.
When sustained analytical ingest stays below about 3,000 events per second (under roughly 200 GB per month compressed) and retention is modest. At that size a separate OLAP cluster is operational overhead you don't need. PostgreSQL declarative range partitioning (version 17 or newer), minute rollup tables, and nightly Parquet archives queried with DuckDB handle internal and moderate B2B dashboards.
With Idealogic's senior Central and Eastern European data engineers at $75 per hour (versus $165 per hour at US agency rates), a PostgreSQL partitioned rollup and Parquet sprint costs $9,000 to $13,500. A managed ClickHouse Cloud or Tiger Cloud setup runs $13,500 to $21,000. A 580-hour owned Apache 2.0 ClickHouse platform on Kubernetes with S3 tiering and multi-tenant ROW POLICY isolation costs $43,500 ($95,700 at US rates). In our 36-month model at 30,000 events per second it saves $145,800 to $448,500 against the managed and RDS options.
More from the journal

PlanetScale vs Neon in 2026: Metal NVMe, CoW & PG17 TCO
Engineering and 36-month TCO teardown of PlanetScale for Postgres vs Neon (Databricks) and AWS Aurora I/O-Optimized in 2026: local NVMe Metal unlimited IOPS vs disaggregated Pageservers, CoW branching, Neki sharding preview, FORCE RLS on PG17, and 1.2 TB math.

GrowthBook vs LaunchDarkly in 2026: Flags, CUPED & TCO
Engineering and 36-month TCO benchmark of GrowthBook vs LaunchDarkly in 2026 alongside Statsig (OpenAI / Amplitude) and CNCF OpenFeature: warehouse-native CUPED SQL, client MAU vs $40/seat billing, PG17 SSE providers, and 500k-MAU math.

Airbyte vs Fivetran in 2026: MAR, dbt Merger, CDC & TCO
Engineering and 36-month TCO benchmark of Airbyte vs Fivetran in 2026: Fivetran + dbt Labs merger lock-in, unpooled MAR vs Data Workers, PostgreSQL 17 pgoutput WAL slot guards, S3 Iceberg ELT, and 180M MAR/mo math.