Which Cloud Lakehouse Platform Has the Fastest Query Performance on Apache Iceberg?
No single platform wins on Iceberg query speed. Compare Snowflake, Databricks, BigQuery, Trino and others by cold reads, tail latency and cost per workload.
There is no single fastest cloud lakehouse platform for Apache Iceberg queries. Iceberg query speed is produced by four layers working together — engine execution, table and metadata services, file layout, and object storage — and the winner changes depending on which metric you measure: cold-read latency, warm-cache latency, p95/p99 tail latency under concurrency, throughput, or cost per completed workload.
That answer is unsatisfying but actionable. It means the comparison you need is not a leaderboard but a mapping from your workload shape to the layer that will bottleneck it. The sections below define the criteria first, compare platforms against each documented approach, and then give you a benchmark protocol you can run on your own tables. Vendor headline numbers, including TPC-DS speedups, are claims to validate in your environment, not verdicts to adopt.
The Evaluation Criteria That Actually Decide "Fastest"
"Fastest" is only meaningful once you fix the metric and the layer. A platform that wins on warm-cache averages can lose badly on cold reads, and one that leads on single-query latency can collapse at 40 concurrent users.
Pick the metric before the platform. Five measurements matter, and they are not interchangeable:
Cold-read latency — the first query against a snapshot with no cached metadata or data. This is dominated by planning hops to object storage, not by CPU.
Warm latency — repeat queries where metadata, footers, or result sets are cached. Most published benchmark wins live here.
Tail latency (p95/p99) — the slow queries your analysts and dashboards actually complain about. Averages hide them.
Concurrency behavior — throughput and latency stability as simultaneous BI, ETL, and agent queries contend for the same tables.
Cost per workload — the metric that converts runtime into a budget decision.
A single average number misleads on two counts. It compresses a long tail into a comfortable middle, and it usually reflects a warmed system, hiding the cold-start cost your first morning query pays.
Then locate the layer. Iceberg read performance comes from four layers, and each is partly under your control:
Engine execution — vectorized readers, cost-based optimization, runtime filters, join reordering.
Table and metadata service — catalog, manifest planning, metadata caching. Iceberg's scan planning is designed to fit on a single node: the manifest list carries partition value ranges that prune manifests before any data file is read, and column-level lower and upper bounds eliminate files at planning time. The Iceberg docs cite cases where that pruning alone produced a 10x performance improvement.
File layout — file sizing, compaction, partitioning, and delete-file handling. Iceberg's configuration reference exposes the knobs that govern this:
read.split.target-sizedefaults to 128 MB,write.target-file-size-bytesto 512 MB, andread.parquet.vectorization.enabledis on by default.Object storage — locality, request amplification, and whether a caching tier sits in front of it.
The practical consequence: the same engine can look fast or slow on two tables in the same account. "Platform speed" is partly a table-hygiene question, and any comparison that holds maintenance constant across platforms is measuring the engine, not the platform-plus-operations bundle you would actually run.
Summary Comparison Matrix
The table below summarizes what each vendor documents about its Iceberg read path. It is a documentation-based summary, not a benchmark result, and no cell should be read as a ranking. Where a vendor publishes performance claims, they appear in the cold-read and warm-cache sections with their scope attached.
Platform | Cold-read approach (documented) | Metadata / caching strategy | Engine optimizer strengths | Concurrency model | Documented performance evidence | Cost model | Best fit |
|---|---|---|---|---|---|---|---|
Snowflake | Reads Iceberg through an external volume; supports Snowflake-managed or external catalogs | Snowflake-managed metadata; vendor advises regular compaction to remove old delete files for best read performance | Cost-based optimizer on its own execution engine | Multi-cluster warehouses | Third-party TPC-DS 1TB comparison (see warm-cache section) | Credit-based warehouses | Teams already standardized on Snowflake governance |
Databricks | Managed Iceberg tables integrated with platform features | Predictive optimization runs | Spark/Photon lineage; clustering and predictive maintenance | SQL warehouses, multi-cluster | Vendor documentation on optimization behavior; no neutral Iceberg benchmark cited here | DBUs | Teams with heavy Spark investment and Delta–Iceberg overlap |
BigQuery | Managed Iceberg tables with automatic compaction and clustering | Metadata caching; background compaction, snapshot management | Serverless execution; automatic clustering | Serverless, slot-based | Vendor documentation on automatic maintenance | On-demand per TiB read or slot commitments | GCP-native teams wanting serverless operations |
Athena / Redshift | Query Glue-cataloged Iceberg; Redshift RG and Serverless use their own compute, RA3 uses Spectrum | Glue Data Catalog as metastore | Spectrum and Redshift optimizer paths | Provisioned or serverless | AWS documentation on query paths | Athena per TB scanned; Redshift cluster/serverless | AWS-native ad hoc and warehouse-integrated querying |
Trino / Starburst | Distributed scan planning with dynamic filtering | In-memory metadata cache on the coordinator; optional Parquet footer cache | Cost-based optimizer, dynamic filters, projection pushdown | Cluster-sized; multi-cluster in managed offerings | Third-party TPC-DS 1TB comparison (see warm-cache section) | Compute-hours on your own or managed clusters | Engine-agnostic querying across clouds and catalogs |
StarRocks | Shared-data architecture reading Iceberg catalogs (e.g., Glue) | Local caching in shared-data deployments | Vectorized executor, CBO with | Shared-data elastic compute | Vendor-published TPC-DS comparison against Trino on the same Iceberg catalog | Compute + storage separation | Latency-sensitive analytics with cache-friendly access |
Dremio | Adaptive planning plus Arrow Flight transport | Columnar Cloud Cache (C3); automatic reflections derived from Iceberg metadata | Adaptive cost-based optimization, Arrow columnar execution | Cluster-based | Vendor-reported 22-second full TPC-DS 1TB run on an 8-node m7gd.4xlarge cluster | Compute-hours | Teams wanting automatic data optimization without manual materialized views |
Firebolt | Reads Iceberg metadata from manifests; caches metadata and data on local SSD plus in-memory metadata snapshots | Metadata and data caching with | Optimizer uses manifest row counts to skip data files entirely | Elastic compute | Vendor documentation on caching and staleness controls | Compute + storage | Latency-sensitive workloads tolerant of bounded staleness |
Singdata | Cloud-agnostic lakehouse on a single-engine architecture | Incremental compute engine; unified architecture replacing separate Spark, Flink, and warehouse tiers | Single engine for ingestion through analytics | Elastic, AI-workload oriented | Vendor-reported claims to validate in your own environment | Consumption-based | Teams prioritizing architecture simplicity and cost efficiency |
Read the matrix as a shortlist generator. If your pain is cold-read planning overhead, look at the metadata-caching rows. If it is tail latency at 50 concurrent users, look at the concurrency column. If it is the bill, look at the cost model.
Cold-Read Latency: How Each Platform Handles the First Query
Cold reads are where the platforms diverge most, and where the reader has the most leverage. The dominant cost is usually metadata traversal, not data scanning.
Firebolt documents the mechanics plainly: Iceberg metadata has multiple layers, so the catalog points to a metadata file, which points to manifest lists, which point to manifest files, which finally point to data files. Because object storage latencies are often above 50 ms, uncached Iceberg reads typically carry at least 200 ms of pure metadata overhead. Firebolt's answer is caching metadata and data on local SSDs plus in-memory snapshot caching, with MAX_STALENESS letting you trade freshness for cache hits. It also uses partition summaries in the manifest list to eliminate entire manifest files before considering their data files.
Trino and Starburst attack the same problem from the planner side. The Trino Iceberg connector enables in-memory metadata caching on the coordinator by default (iceberg.metadata-cache.enabled), exposes iceberg.dynamic-filtering.wait-timeout to bound how long split generation waits for dynamic filters, and offers an optional Parquet footer cache. Those settings change cold-read behavior materially, which is why "Trino's cold latency" is not a single number.
Snowflake reads Iceberg through an external volume and supports both Snowflake-managed and external catalogs. Its documentation is explicit that Snowflake does not assume lifecycle management on the table, and recommends regular compaction and table maintenance to remove old delete files for best read performance when row-level deletes are in use. That is a cold-read statement disguised as a maintenance note: delete-file accumulation is a planning and scanning cost you own.
Databricks integrates managed Iceberg tables with predictive optimization, which runs OPTIMIZE automatically, with manual runs available for reclustering after clustering-key changes. BigQuery's managed Iceberg tables perform automatic compaction and clustering, and Google Cloud's lakehouse documentation describes background compaction and snapshot management alongside metadata caching.
Dremio reports that a full 1TB TPC-DS run completed all 99 queries in 22 seconds on an 8-node m7gd.4xlarge cluster, with no tuning. Treat that as a vendor-reported, environment-specific result — it tells you the engine is fast on that configuration, not that it will be fast on your table layout.
The pattern across all of them: cold-read performance is dominated by metadata planning and file layout, both of which you control. A well-compacted, well-partitioned table can make a mid-tier engine look excellent; a table full of small files and delete files will make any engine look slow.
Warm and Cached Performance: Where Vendor Benchmarks Live
Most headline Iceberg benchmark wins are warm-cache results, and that is not dishonest — it just describes a different workload than a cold Monday morning.
The caching approaches differ in kind, not only degree. Firebolt caches metadata and data on local SSD and keeps in-memory snapshots of Iceberg metadata, which matters because a single query otherwise walks catalog, metadata file, manifest list, manifest files and data files in sequence. StarRocks uses local caching in shared-data deployments. Dremio layers Columnar Cloud Cache with automatically generated reflections that it maintains incrementally, and reports that in its internal lakehouse 80% of dashboards were accelerated automatically with 90th-percentile query time dropping from 13 seconds to under 1 second — a vendor-reported internal figure, not an independent measurement. VeloDB describes materialized views on lake tables that its optimizer rewrites transparently, citing Apache Doris documentation reporting up to 93x improvement in tested scenarios while noting the speedup depends on the ratio of pre-computed work to query complexity. Trino and BigQuery both offer metadata and result caching of varying scope.
The clearest worked example of how much caching and configuration move the number is the Concurrency Labs 1TB TPC-DS comparison of Starburst Galaxy against Snowflake on Iceberg tables in S3. On average execution time, Starburst Galaxy recorded 9 seconds against Snowflake's 47 seconds with a single X-Large warehouse, and 8 seconds against Snowflake's three-cluster configuration. Median told a similar story: 6 seconds versus 22 and 4.
Those numbers are real, and they are also narrow. The dataset was a single 1TB TPC-DS set in one region (N. Virginia), 12,696 files totaling 234 GB, driven by JMeter from a single EC2 instance. The author is vendor-adjacent. And as the next section explains, neither platform disclosed underlying vCPU or memory, so "equivalent configuration" is an assumption rather than a verified fact.
Warm numbers are predictive only when your cache-hit profile matches the benchmark's. If your analysts re-run the same twenty dashboards all day, warm performance is your performance. If your workload is exploratory queries over freshly landed partitions, the warm benchmark describes a system you rarely see.
Concurrency and Tail Latency Under Mixed Workloads
Production readers feel tail latency, not averages. A platform with a 4-second median and a 90-second p99 will generate more complaints than one with a 9-second median and a 15-second p99.
The Concurrency Labs data illustrates how much of tail behavior is a configuration decision rather than an engine property. Snowflake's single X-Large warehouse recorded an average of 47 seconds and a maximum of 373 seconds across the query set; the same warehouse scaled to three clusters recorded an average of 8 seconds and a maximum of 158 seconds. The average roughly halved and the tail compressed substantially — from the same engine, with a concurrency setting changed.
That is the general lesson. Snowflake multi-cluster warehouses, Databricks SQL warehouses, and StarRocks shared-data compute groups all exist to absorb concurrent load by adding compute, and all of them change your p95 more than any optimizer tweak will. Isolation between ETL and BI matters for the same reason: a nightly compaction or large write competing with a dashboard query produces exactly the tail spikes that averages conceal.
Agentic and AI workloads change the shape of the problem again. Continuous, machine-generated query streams do not follow human business hours, so the idle window that let a fixed cluster absorb peak load disappears. Singdata's positioning addresses this directly — the company describes AI agents querying data around the clock at a scale no human team reached, and frames its incremental compute model as the economics for that pattern. That is a vendor claim about workload economics, not a measured latency result, and it should be validated against your own concurrency profile.
When you evaluate platforms here, ask for p95 and p99 at your target concurrency, not throughput at saturation. Throughput numbers tell you how much work a system completes; tail numbers tell you whether your users wait.
Cost per Workload: The Metric That Reframes "Fastest"
"Fastest per dollar" is usually the real decision criterion, and it is the one most benchmark comparisons omit.
The cost models are structurally different, which makes naive comparison dangerous. Snowflake bills credits against warehouse size and runtime. Databricks bills DBUs. BigQuery charges per TiB read on on-demand pricing or against slot commitments. Athena charges per terabyte scanned, which makes partition pruning and file layout direct cost levers. Open engines such as Trino run on compute you provision, so the bill arrives as infrastructure rather than as a query charge.
VeloDB frames the arithmetic cleanly: a system completing all 99 TPC-DS queries in the same time as a competitor but at half the hourly compute rate delivers twice the value. In its published configuration table, VeloDB and "Product D" both ran at roughly $10/hour on about 96 cores and 768 GB against TPC-DS 1TB in Iceberg format with local disk cache. The vendor also models a workload costing $50,000/year on "Product S" at roughly $22,000 on VeloDB, while stating that actual numbers will vary. Both are vendor-reported.
The Concurrency Labs comparison puts a third-party estimate on the same question: an always-on Starburst Galaxy Large cluster at approximately $32.3K per month, versus approximately $104K per month for the Snowflake configuration with equivalent measured performance — a 3.2x difference, in the author's calculation. Scope it carefully: one dataset, one region, one query mix, vendor-adjacent authorship.
The industry has moved toward treating cost as part of performance rather than a separate concern. The TPC's own description of TPC-DS V4 centers on a Dynamic Pricing Model that decouples compute from storage and scales each independently, replacing a static price/performance figure with one that reflects consumption. The TPC notes that because of these architectural changes, V4 results are not comparable with any previous version of the benchmark — a reminder to check which version any vendor number comes from.
None of this tells you which platform is cheapest for you. It tells you what to model: your query volume, your scan volume after pruning, your concurrency peaks, and how much of your day is idle.
Why Vendor Benchmarks Rarely Transfer to Your Tables
Vendor benchmarks fail to transfer for methodological reasons, not because vendors lie. The gap is between the conditions a benchmark fixes and the conditions your tables present.
Scale factor. The TPC-DS specification requires that, when results measured against different database sizes appear in a communication, each reference to a result or metric clearly indicate the database size against which it was obtained, and that textual references to TPC-DS metrics use the "@size" suffix to include the test database size as an integral part of the metric name. It also mandates a disclaimer: "The TPC believes that comparisons of TPC-DS results measured against different database sizes are misleading and discourages such comparisons." A 1TB result and a 10TB result are not the same measurement, and neither predicts your 40TB table.
Hardware opacity. The Concurrency Labs author notes that both Starburst Galaxy and Snowflake document how to launch compute but neither exposes underlying vCPU or memory for each deployment type, which limits the context available for comparing against EC2 or EMR alternatives, leaving cost relative to performance as the main comparison that can be made. When you cannot see the hardware, "equivalent performance" is an inference.
Cache state. As covered above, cold and warm runs measure different systems. A benchmark that does not state its cache state is not reproducible.
Query mix and concurrency. TPC-DS defines four query classes — reporting, ad hoc, iterative OLAP, and data mining — and a benchmark's aggregate score weights them by its own stream design, not yours. Reporting queries that repeat benefit from caching in ways ad hoc exploration does not.
Reporting choices. Average, median, and maximum diverge sharply. In the Concurrency Labs data, Snowflake's single-cluster average was 47 seconds while its median was 22 — the mean was pulled up by outliers reaching 373 seconds. A vendor quoting the more favorable statistic is not misrepresenting, but you should know which one you are reading.
Version drift. TPC-DS V4's pricing changes make its results incomparable with earlier versions, and Iceberg itself evolves — table format v4 introduces constraints and Parquet root manifests that earlier readers handle differently.
The conclusion is not to ignore benchmarks. It is to use them for shortlisting and to run your own measurement before committing.
A Benchmark Protocol You Can Run on Your Own Iceberg Tables
This protocol produces a comparison you can defend in a procurement review. It takes a few days per platform and replaces every vendor number with one measured on your data.
Fix a representative dataset and snapshot. Choose tables that reflect your real scale and skew, and pin a snapshot ID so every platform reads identical files. Record row counts per table so you can confirm the data matches.
Define cold and warm runs explicitly. For cold runs, flush caches between executions — restart compute, clear local SSD caches, and disable result caches where the platform allows. Run each query once cold, then repeat for warm. State which is which in your results.
Capture p50, p95, and p99. Do not report only the mean. Log per-query elapsed time and compute percentiles across the run.
Test at your target concurrency with a realistic mix. Combine BI-style reporting queries, a write or compaction job, and any agent or API-driven query stream. A single-user benchmark answers a question nobody asked.
Measure cost per workload, not just runtime. Multiply measured runtime by the platform's unit price for the configuration used, and include storage and any per-scan charges. Report cost per completed query set.
Hold table maintenance constant. Run compaction,
ANALYZE TABLE, and statistics collection to the same standard on every platform before measuring. Iceberg's configuration reference gives the knobs to pin:read.split.target-size(default 128 MB),read.parquet.vectorization.enabled(default true), andwrite.target-file-size-bytes(default 512 MB). If one platform auto-compacts and another does not, note it — that difference is part of the product.Record configuration and versions. Engine version, cluster size, warehouse size, cache settings, and catalog type. Without these the run is not reproducible.
A compact log per run:
Field | Example entry (illustrative) |
|---|---|
Platform and version | Engine vX.Y, 5-node cluster |
Catalog | Glue / REST / vendor-managed |
Table snapshot ID | Pinned per table |
Cache state | Cold (flushed) or warm (3rd run) |
Concurrency | 1, 10, 40 users |
Latency p50 / p95 / p99 | Recorded per query and aggregate |
Cost per run | Compute hours × unit price + scan charges |
Maintenance applied | Compaction + ANALYZE, identical across platforms |
As an illustration of why the log matters: a team measuring two engines might see 9 seconds and 47 seconds on average and conclude a 5x gap, then discover after logging that one ran three clusters and the other ran one. The log is what turns a number into a finding.
Platform-by-Platform: Who Should Choose Which
Self-selection beats ranking. Each platform below wins on a specific set of conditions and loses on others.
Snowflake fits teams already standardized on its governance, RBAC, and catalog. It reads Iceberg through an external volume with either a Snowflake-managed or external catalog, so you keep open-format storage while querying through Snowflake. It loses ground when you need the lowest cold-read latency on unmanaged tables, because table lifecycle is yours to run — the documentation is explicit that Snowflake does not assume lifecycle management.
Databricks fits organizations with substantial Spark investment. Managed Iceberg tables integrate with predictive optimization, which runs OPTIMIZE automatically, so maintenance is partly handled for you. It is a weaker fit if you want engine neutrality or are standardizing on a non-Spark execution path.
BigQuery fits GCP-native teams that want serverless operations and automatic compaction and clustering on managed Iceberg tables. It is a weaker fit for multi-cloud engine neutrality or for workloads where per-TB scan pricing is hard to bound.
Athena and Redshift fit AWS-native estates already using Glue as a catalog. Redshift RG instances and Serverless use their own compute for data lake queries while RA3 instances use Spectrum, so the query path depends on your instance type. Athena's per-TB-scanned pricing makes file layout a direct cost lever.
Trino and Starburst fit teams that want one engine across clouds and catalogs. The connector exposes metadata caching, dynamic filtering timeouts, and split sizing, so performance is tunable rather than fixed — which is also the cost, since tuning is your job.
StarRocks, Dremio, Firebolt, and VeloDB fit latency-sensitive, cache-heavy analytical workloads. StarRocks documents TPC-DS results on Iceberg catalogs using Glue and Parquet with ZSTD, with queries warmed once and averaged over three runs. Dremio automates data optimization through reflections derived from Iceberg metadata. Firebolt caches metadata and data aggressively with MAX_STALENESS controls. VeloDB routes lake queries through the same optimizer and vectorized executor as internal tables. Each trades some freshness control or operational simplicity for speed.
Singdata fits teams whose primary constraint is architecture complexity and cost efficiency rather than a single-query latency record. It is positioned as a cloud-agnostic, AI-native lakehouse on a single-engine architecture, with an incremental compute engine intended to replace separate Spark, Flink, and warehouse tiers. The company reports headline speed and TCO figures; as with every vendor in this article, those are claims to validate in your own benchmark rather than adopt as a verdict.
An Acceptance Checklist Before You Commit
Use this list in the evaluation, not after signing. Each item maps to a criterion established earlier.
Can you benchmark on your own Iceberg tables? Trial terms, data egress, and connector support must permit it before you commit.
Is cold-read behavior documented? Look for explicit statements about metadata caching, planning hops, and what happens on first access to a new snapshot.
Does it expose p95 and p99? Query history and monitoring should surface percentiles, not only averages, and should let you segment by concurrency.
Who handles delete files and compaction? Determine whether the platform compacts automatically, offers a managed job, or leaves it to you — and price the difference in engineering time.
What is the cost model at your workload shape? Model credits, DBUs, slots, or per-TB scans against your measured scan volume after pruning, not against raw table size.
Can you exit without rewriting tables? Confirm open-format storage, external catalog support, and that metadata remains readable by other engines.
Are the tuning knobs exposed? Split sizing, vectorization, and statistics collection should be configurable so you can hold them constant across platforms — and so you can tune them later.
Is concurrency isolation available? Separate compute for ETL and BI is the most reliable defense against tail latency.
If a vendor cannot answer the first four items, the benchmark conversation is premature.
FAQ
Short answers to the questions that decide most Iceberg evaluations, each pointing back to the section that develops it.
Is there a single fastest Iceberg platform? No. Query speed on Iceberg is set by four interacting layers — engine execution, table and metadata service, file layout, and object storage — and by which metric you measure. A platform that leads on warm-cache p50 latency can trail on cold reads or on p95 under concurrency. See The Evaluation Criteria That Actually Decide "Fastest".
Are vendor TPC-DS numbers trustworthy? Treat them as directional, not as verdicts. Vendors run different scale factors, cluster sizes, cache states and query mixes, and the TPC itself discourages comparing results across database sizes. The benchmark-transfer section lists the specific gaps to check before you quote a number internally.
Does the query engine or the table format matter more? Both, and they interact. Iceberg's manifest-list pruning and column-level statistics eliminate files at planning time, but an engine still has to exploit them; the same engine can look fast on a well-compacted table and slow on one littered with small files and delete files. Table maintenance is part of platform performance, not a separate chore.
Is warm-cache performance representative? Only if your cache-hit profile matches the benchmark's. Warm numbers are real, but they describe repeated access to a working set that already sits in local SSD or memory. If your analysts and agents query cold partitions daily, the cold-read comparison is the more relevant one.
How does Singdata compare? Judge it on the same criteria as everything else: cloud-agnostic deployment, a single-engine architecture that replaces separate Spark, Flink and warehouse tiers, and incremental compute aimed at cost per workload rather than headline speed. The selection guide explains which teams that profile fits — and which it does not.