Talk with our engineers by joining the new Onehouse community Slack!

TL;DR
- Choose Onehouse for Spark or ingestion-heavy pipelines and a fully-featured Kubernetes-native lakehouse. Its integrated AI data layer combines Lakegres for low-latency agent queries and indexed retrieval with governed model access and training-data pipelines.
- Choose Starburst Enterprise for interactive SQL and federated queries across existing systems. Pair with other platforms for Ingestion, Spark and many platform features.
- Choose Cloudera to extend an existing HDFS estate with a full-stack platform. Expect a separate Base cluster infrastructure, slower spark/queries and more assembly for AI data workflows.
Introduction
The data lakehouse has become the industry standard for building analytics and AI data platforms. In the cloud you have plenty of options, from the cloud providers’ own services on AWS, Google Cloud and Azure to Snowflake and Databricks. None of them is built to run on infrastructure you own in a data center, or on a neocloud. For those environments the options are Onehouse, Starburst Enterprise and Cloudera. This article compares the three feature by feature. It covers only what each product does on-prem, and every claim links to the vendor’s own documentation.
We think this comparison matters more today than it would have a few years ago. For most of the last decade, choosing a data platform started with choosing a cloud, and the consumption model was to move your data into that cloud and use the data services available there. AI is starting to break that assumption. A 2026 survey of 1,800 IT leaders found that 56% run or plan to run production AI inference on private cloud, and an IDC whitepaper found AI to be the top reason enterprises are moving workloads off public cloud. A lot of valuable data never left the data center in the first place. Decades of documents, images, engineering data and research archives still sit on enterprise file systems and object stores, and the GPU clusters going into private AI factories are generating new datasets right next to them.
The work being done on that data is changing too. Lakehouse workloads used to be driven by people, with engineers building pipelines, analysts querying the results in SQL and data scientists training models on the same tables. Agents now work on that data as well, and a single agent can issue dozens of SQL and search requests to answer one question. An on-prem platform still has to do ETL, change data capture and interactive SQL on structured tables. It also has to turn documents into something searchable and serve agents at low latency.
Starburst Galaxy and Cloudera on public cloud have different feature sets, so nothing here should be read as a statement about those products. On the other hand, Onehouse on AWS or Google Cloud or Azure runs with the same feature set. This blog focuses heavily on features and leaves performance to a short section at the end.
We obviously build Onehouse, but we have written plenty of objective comparison articles that are data-driven and verifiable, covering table formats, analytics engines, stream processing engines and data science and ML engines. This one is no exception, as we strap our own platform to the same apparatus.
The three platforms at a glance
The three products were built for different jobs, which explains most of the differences in the tables further down.
| Onehouse | Starburst Enterprise | Cloudera on premises | |
|---|---|---|---|
| What it is | Managed lakehouse platform: ingestion, Apache Spark™ and SQL pipelines, table optimization, interactive SQL (platform guide) | Commercial distribution of Trino, a distributed SQL query engine, with governance, data products and AI features (docs) | Full data platform descended from Apache Hadoop™: storage, ingestion, Spark, SQL engines and machine learning (release summary) |
| Engines | Quanton for Spark and SQL, Lakegres for Postgres-compatible interactive SQL; (product maturity) | Trino | Spark, Apache Impala™, Apache Hive™, Trino, Apache NiFi™, Flink |
| Who operates it | You provide a Kubernetes cluster; Onehouse installs, upgrades and operates the platform remotely (deployment) | You operate it, on Kubernetes with Helm or on VMs with Starburst Admin (Kubernetes, Starburst Admin) | You operate it: a Base cluster on bare metal or VMs, plus Data Services on Red Hat OpenShift or Cloudera’s embedded Kubernetes (prerequisites) |
| Primary storage | Any S3-compatible object store, or HDFS | S3-compatible object stores, or HDFS (object storage) | HDFS or Apache Ozone™ on Cloudera-managed nodes, with component-specific access to external S3-compatible stores |
| Table formats written | Apache Hudi™, Apache Iceberg™, Delta Lake | Iceberg, Delta Lake, Hive | Iceberg, Hive; Delta Lake writes through the Trino Lakehouse connector |
| Version compared | Platform guide, November 16, 2026 | 483-e STS (latest LTS is 482-e), as of November 16, 2026 | Base 7.3.2, Data Services 1.5.5 SP4; Flow Management 4.13 and Streaming Analytics 1.18 where noted, as of November 16, 2026 |
Feature comparison
Each cell in the tables below is graded. Green (Yes) means the on-prem product meets the requirement in the row, within the scope stated in its cell. Yellow (Partly) means a restriction on formats, sources or functionality leaves part of that requirement unmet, or the capability needs a pipeline or integration you build yourself. Red (No) means we could not find the capability in the on-prem documentation. Routine configuration does not by itself make a capability yellow; a green cell can name the format it supports when the row does not require all formats. We compared Starburst Enterprise 483-e, Cloudera Base 7.3.2 with Data Services 1.5.5 SP4, and the Onehouse platform guide as of November 16, 2026.
Deployment and storage
| Onehouse | Starburst Enterprise | Cloudera on premises | |
|---|---|---|---|
| Kubernetes-only footprint (Can I run the platform on my existing Kubernetes and object storage, without a separate underlying data platform?) | Yes. The data plane depends only on Kubernetes and object storage (bring your own Kubernetes). | Yes. Helm charts for Kubernetes and OpenShift (Kubernetes). It needs an external database for its backend service and a metastore, either Hive Metastore or the Starburst Metastore. | No. Data Services run on OpenShift or Cloudera Embedded Container Service and rely on a Base cluster on bare metal or VMs for storage, metastore and security (pricing update, prerequisites). |
| Bring your own object store (Can the S3-compatible store I already own be the primary storage?) | Yes. Any S3-compatible store. The platform has no storage tier of its own (bring your own Kubernetes). NetApp has published validation of Onehouse on StorageGRID, covering Spark ETL, Iceberg writes and table maintenance (NetApp blog). | Yes. S3-compatible stores through its object storage support, with dedicated pages for MinIO and Dell. NetApp has published a validation on ONTAP S3 and StorageGRID (NetApp blog). | Partly. External S3-compatible storage is supported by individual services, including Data Warehouse and AI Registry. This does not replace the Base cluster: Data Engineering still requires Ozone for its service dependencies (prerequisites). |
| Existing HDFS (Can I point it at the HDFS cluster I already run?) | Yes. Works with HDFS and other Hadoop-compatible file systems, including an existing Cloudera cluster (bring your own Kubernetes). | Yes. HDFS file system support with Kerberos, and a Cloudera Data Platform support page for the Hive connector. | Yes. HDFS is part of the Base cluster (Cloudera Manager docs). |
| Air-gapped operation (Can I run it with no outbound network connection?) | No. Air-gapped environments are not supported out of the box: the standard deployment needs outbound access to the Onehouse control plane (bring your own Kubernetes). Air-gapped operation is technically possible with a custom control-plane deployment, which Onehouse considers on a case-by-case basis. | Yes. Self-managed software activated by a license file (license). Starburst states that Enterprise supports air-gapped environments (May 2025 release coverage). | Yes. Documented air-gap install for Data Services (air gap installation). |
| Vendor-operated (Can the vendor install, upgrade and operate the platform for me in my data center?) | Yes. Onehouse installs, upgrades and operates the data plane remotely (operations). | No. You deploy and upgrade with Helm or Starburst Admin (Kubernetes). Starburst provides 24x7 support (docs). | No. You install and upgrade through Cloudera Manager and the Management Console (upgrade guide). |
Ingestion
| Onehouse | Starburst Enterprise | Cloudera on premises | |
|---|---|---|---|
| Database change data capture (Can I replicate changes from operational databases into lakehouse tables without building a pipeline?) | Yes. OneFlow captures database changes into tables from a source, target and write mode set in the console or API (ingestion). LakeLog stages the change log on the object store, so no Apache Kafka™ cluster is needed (LakeLog). | No. Managed ingestion is a Starburst Galaxy feature today, and Starburst has said it is bringing it to Enterprise (Starburst blog). Enterprise can query the source database in place through its connectors. | Partly. NiFi ships Debezium CDC processors and a PutIcebergCDC writer (supported processors). You design, size and operate the flow on a dedicated NiFi cluster (cluster layout). |
| Managed CDC buffering (Can I durably buffer database changes without deploying and operating a separate ingestion or messaging cluster?) | Yes. LakeLog stages CDC events as open tables on your object storage, with no Kafka cluster to size or operate. Producers send events over HTTP using a Confluent REST Proxy-compatible producer API; OneFlow and other table readers consume the log incrementally. | No. Enterprise has no built-in CDC capture and buffering service. Its Kafka connector reads an existing Kafka deployment; the ingestion and durable log must be supplied separately. | Partly. NiFi's Debezium processors can capture changes directly into NiFi flows without Kafka. You still deploy and operate the NiFi cluster and its persistent queues and repositories. |
| Streams (Can I land Kafka topics as tables continuously?) | Yes. Kafka-compatible sources including Apache Kafka and Confluent (product maturity). | Partly. The Kafka connector queries topics as tables, and a scheduled SQL job can insert them into Iceberg. The continuous Kafka-to-Iceberg service is in Galaxy (Icehouse Ingest). | Yes. NiFi and Kafka Connect (Kafka Connect connectors), with Flink and SQL Stream Builder for streaming SQL (Streaming Analytics). |
| File ingestion (Can raw file drops be ingested continuously into lakehouse tables without building and operating a custom pipeline?) | Yes. OneFlow ingests raw files into lakehouse tables, managing checkpoints, retries and scaling. File sources use bucket notifications where available and poll the prefix on stores that do not emit them (file discovery). | No. We did not find a built-in, notification-driven raw-file ingestion service in Enterprise. The Hive connector and SQL storage functions read files into queries; automated file discovery and ingestion require additional orchestration. Managed file ingestion is a Galaxy feature. | Partly. NiFi supports notification-driven ingestion: its documented S3 recipe connects GetSQS, event parsing and FetchS3Object. You build and operate the flow that discovers, fetches, parses and writes files into lake tables. List-and-fetch processors are another option; an event-driven path depends on the source store's notification integration. |
| Schema changes (Do source schema changes reach the table without manual work?) | Yes. Backward-compatible changes are applied automatically: new nullable columns, retired columns and type widening (ingestion). | No. There is no on-premises ingestion service to apply them. Iceberg schema evolution is available through SQL (Iceberg connector). | No. Schema Registry covers Avro and JSON on the wire (what’s new). The evolution policy on the target table is the flow author’s job. |
Transformation and ETL
| Onehouse | Starburst Enterprise | Cloudera on premises | |
|---|---|---|---|
| Spark jobs (Can I run my existing Spark code?) | Yes. Quanton is Spark-compatible. Scala, PySpark and Spark SQL jobs run unchanged (Quanton engine, Spark jobs). | No. Enterprise executes Trino queries; it does not run existing Spark jobs. PyStarburst provides Python DataFrame syntax for transformations executed by Trino. It does not supply a Spark runtime. | Yes. Open-source Spark 3.5.4 in Data Engineering on Kubernetes (Spark versions). A job needs a Virtual Cluster created first (create a job). |
| SQL pipelines (Can I build and schedule transformations in SQL alone?) | Yes. SQL clusters and dbt (SQL pipelines, product maturity). | Yes. SQL jobs run statements such as MERGE on a schedule, and materialized views refresh on a schedule. | Yes. Spark SQL in Data Engineering with an embedded Apache Airflow™ (Airflow in CDE), plus Hive, Impala and Trino in Data Warehouse. |
| Incremental processing (Can a pipeline process only the rows that changed since its last run?) | Yes. OneFlow processes table changes natively, with checkpoints committed alongside the data. Quanton Spark jobs support Iceberg change processing with Scala, Java or Python code. For Hudi, latest-state incremental queries return one final record per inserted or updated key in a window, avoiding repeated processing of intermediate versions. Index-aware joins and MERGE reduce target scans and shuffles. | Partly. SQL functions read Iceberg snapshot changes and Delta change feeds. You assemble the processing and checkpoint logic; Iceberg change reads require retained snapshots and exclude snapshots containing delete files. The runtime executes Trino queries, with no general-purpose Spark job execution. | Partly. Data Engineering supports Spark Structured Streaming with Kafka, but Spark streaming with Iceberg is unsupported in the compared CDE release. Hive materialized views rebuild incrementally for appends; deletes and other changes require a full rebuild. |
Table formats and table maintenance
| Onehouse | Starburst Enterprise | Cloudera on premises | |
|---|---|---|---|
| Format choice (Can I write Hudi, Iceberg and Delta Lake tables from the same platform?) | Yes. All three are written natively, and Apache XTable™ (Incubating) exposes a table in all three (formats and optimization, catalog interoperability). | Partly. Reads and writes Iceberg and Delta Lake. The Hudi connector is read-only. | Partly. Iceberg is supported across Spark, Impala and Hive (Iceberg overview). Data Warehouse also ships a Trino Lakehouse connector with Delta Lake writes; its Hudi support is read-only. |
| Automatic table maintenance (Are compaction, snapshot expiry and cleanup handled without me writing maintenance jobs?) | Yes. Table Optimizer maintains managed and registered Hudi/Iceberg tables. Flow-created tables get cleaning and compaction automatically; other services, including incremental clustering with linear, Z-order or Hilbert sorting, are enabled per table and triggered by commit counts or schedules (formats and optimization). | Yes, for Iceberg. Built-in data maintenance jobs schedule compaction, statistics collection, snapshot expiration and orphan-file deletion, including all tables in a schema. The UI supports recurring schedules and cron; its documented job configuration does not expose commit-count triggers. | Yes, for Iceberg. Lakehouse Optimizer automates compaction and snapshot expiration with event-triggered or scheduled policies. You install the service and configure its policies. Hive ACID compaction is also automatic (Hive compaction). |
| Indexes and lookups (Can selective queries and point lookups run fast without a separate serving database?) | Yes. Record-level and secondary indexes on tables (interactive queries). | Yes, for warmed data. Warp Speed builds column indexes asynchronously on local SSDs and supports on-premises S3-compatible storage. Unindexed data is read from object storage; caches and indexes rebuild after a cluster restart. Fast warmup, warmup rules and index/cache resiliency were removed in 479-e. | Partly. Lake-table queries use scans with partition and statistics pruning. Puffin statistics inform query planning; statistics and sketches do not provide a managed record-level secondary index for point lookups. |
Interactive query, BI and federation
| Onehouse | Starburst Enterprise | Cloudera on premises | |
|---|---|---|---|
| Interactive SQL for BI (Can analysts run dashboards and ad hoc SQL at interactive speed?) | Yes. Lakegres clusters with load-aware autoscaling (interactive queries). | Yes. Interactive analytics is the core use of Trino. JDBC and ODBC drivers, a query editor, and integrations with Tableau and Power BI (docs, clients). | Yes. Impala, Hive and Trino Virtual Warehouses, with Hue as the editor (managing warehouses, release summary). |
| Federation (Can I query other databases in place, without copying the data?) | Yes. Open Engines runs managed Trino clusters for querying other sources in place (open engines). | Yes. More than 50 connectors, including Oracle, SQL Server, Teradata, SAP HANA, Snowflake and Salesforce (connector matrix). | Yes. Trino Virtual Warehouses include federation connectors such as Oracle, Apache Kudu™, Hive and Impala (release summary). |
| Postgres compatibility for agents and apps (Can agents and applications query lake tables through existing Postgres drivers and connection code?) | Yes. Lakegres implements the Postgres wire protocol, so agents and applications can use Postgres drivers to query lake tables directly. The same endpoint supports BI tools such as DBeaver, Tableau and Power BI (interactive queries). | No. Direct SQL connections use the Trino protocol and its JDBC, ODBC or Python clients; existing Postgres connection code needs a different client integration (clients). | No. Lake queries use Hive, Impala or Trino client integrations, including JDBC, ODBC, Beeline and impala-shell. They do not expose a native Postgres wire endpoint (querying data). |
| Data products (Can teams publish curated datasets for others to discover and reuse?) | Partly. The semantic layer holds certified metrics and dimensions (semantic layer). There is no data product catalog. | Yes. Data products package datasets with governance and metadata, with AI-generated descriptions (enrichment). | Yes. Data Catalog lets teams create and manage dataset collections organized by business purpose, tags and ownership, so others can discover related assets (managing datasets). |
| Bundled BI (Does a dashboard tool come with the platform?) | Yes. Onehouse ships Apache Superset™ for dashboards and SQL, configured out of the box with Lakegres and the catalog and tables it serves (BYOK8s walkthrough). Other BI tools connect through the Postgres endpoint. | Partly. The AI Data Assistant draws charts in its chat interface (AIDA). Dashboards come from Tableau, Power BI and similar tools. | Yes. Cloudera Data Visualization ships with Data Warehouse (what’s new in SP3) and is priced per user (pricing). |
Catalogs and governance
| Onehouse | Starburst Enterprise | Cloudera on premises | |
|---|---|---|---|
| Fine-grained access control (Can I enforce row filters and column masks?) | Yes. Table and row-level policies, column policies and column masking (governance catalog, product maturity). | Yes. Built-in access control or Apache Ranger™, with row filters and column masking. | Yes. Ranger enforces row filters and column masks through supported query engines (Trino governance). External engines using the Iceberg REST data-sharing path do not receive row filtering or column masking. |
| Open catalog (Can outside engines read and write my tables through a standard catalog API?) | Yes. Iceberg REST, with sync to Hive Metastore, DataHub, Databricks Unity and Snowflake catalogs (catalog interoperability, product maturity). | Yes. Starburst Metastore replaces Hive Metastore and exposes an Iceberg REST API for external engines, introduced in 482-e. | Partly. Hive Metastore is the catalog. The Cloudera Iceberg REST Catalog gives outside engines read-only access to Iceberg tables stored on Ozone (data sharing). |
| Query audit (Can I see who ran what?) | Yes. Audit is part of the platform on every deployment (product maturity, security and governance). | Yes. Query audit, plus an Apache Atlas™ integration (docs). | Yes. Ranger audit and Atlas lineage in the Base cluster (Cloudera Manager docs). |
AI
| Onehouse | Starburst Enterprise | Cloudera on premises | |
|---|---|---|---|
| Unstructured data processing (Can documents, PDFs and images be turned into tables with embeddings inside the platform?) | Yes. Documents, PDFs, images and video are chunked at ingest into tables with embeddings. Incremental refresh processes changed content, merging repeated updates to a record within a batch before calling the embedding model (ingestion). | Partly. SQL AI functions and AI Search turn text into embeddings stored in Iceberg tables (Starburst blog). We did not find parsing or chunking of files such as PDFs and images in the Enterprise docs. | Partly. RAG Studio parses documents into its own vector store (Qdrant, ChromaDB or Cloudera Semantic Search), separate from the lake tables (RAG Studio configuration). |
| Semantic layer (Can I define metrics and business terms once, so people and agents get consistent answers in plain language?) | Yes. Certified metrics and dimensions are defined once and used to answer questions asked in plain language. Generated SQL runs as the asking user (semantic layer). | Yes. Data products act as the semantic layer and hold the business definitions (context layer). The AI Data Assistant answers questions against them, with personas, business rules and guardrails (AIDA). | Partly. Cloudera Data Visualization has dataset modeling and natural-language querying for its own dashboards (press release). The Hue SQL AI Assistant generates SQL without governed metric definitions (what’s new). |
| Agent access over MCP (Can AI agents query governed data through the Model Context Protocol?) | Yes. A built-in MCP server over Onehouse services, including Lakegres, is part of the AI Gateway (AI Gateway). | Yes. The Starburst MCP server exposes queries and data product search, with OAuth. | Partly. Cloudera publishes a separately deployed Iceberg MCP server through Impala, announced as a preview for on-premises and cloud environments. Agent Studio also connects to local MCP servers over stdio. |
| Tool governance (Can agents use tools from multiple MCP servers through one gateway with central permissions and credential handling?) | Yes. The AI Gateway combines built-in and external MCP servers into one endpoint, namespaces their tools, grants tool access by group and brokers credentials for agents (tool governance). | Partly. AIDA connects to external MCP servers with authentication and role-based access. Permissions cover an entire server, including all its tools. The documented integration governs tools used within AIDA sessions; we did not find a shared tool gateway for other agents. | Partly. Agent Studio registers MCP servers and selects tools for agents. It has no product-level allowlist of approved external servers; project Contributors can read provider keys in project environment variables (security responsibilities). |
| Indexed vector search (Can I use vector indexes to search embeddings stored with my lake tables?) | Yes. Vector and full-text indexes on tables (interactive queries). | Partly. AI functions generate embeddings into tables, and SQL computes similarity. We did not find a vector index in the Enterprise docs. | Partly. RAG Studio searches its own store: Qdrant, ChromaDB or Cloudera Semantic Search (RAG Studio configuration). |
| Model gateway (Is there one governed endpoint for routing model access across providers and teams?) | Yes. The AI Gateway stores provider credentials once and adds aliases, fallbacks, and per-user and per-group permissions, with no per-token charge (AI Gateway). | Partly. Model aliases, trusted connections, access control and token usage reporting cover Starburst’s own AI features (configure Starburst AI). | No. We did not find a general-purpose gateway for routing across model providers. AI Studios configure their model connections, and RAG Studio can use Cloudera Inference endpoints through its environment identity (RAG configuration). |
| Agent traces for evaluation and training (Can I collect agent traces as mutable lake tables, add scores later and reuse them in evaluation and training pipelines?) | Yes. Gateway calls and external OpenTelemetry or Langfuse traces land in Iceberg tables in your storage. Add judge scores and labels later, retain versions, and read them through time-travel, incremental or CDC queries for evaluations and RL environments (agent traces). | Partly. AIDA keeps agent session history, and Trino exports query execution traces. We did not find a built-in pipeline collecting external agent traces into mutable lake tables for scoring and training. | Partly. Agent Studio sends workflow traces to Phoenix for monitoring. The documented path uses Phoenix as its trace store; writing and maintaining scored traces as lake tables requires an additional pipeline. |
| Training-data pipelines and provider integration (Can I curate, validate and version training datasets from lake tables, then submit them to a training provider?) | Yes. Quanton curates agent runs and business data into reproducible datasets. Provider-specific exporters validate supervised fine-tuning (SFT), preference or text datasets, with supported shapes varying by provider. Onehouse submits jobs to Baseten, Fireworks or Together AI and tracks their status (training-data pipelines). | Partly. SQL and AI functions can prepare training examples. We did not find built-in provider-specific training-dataset validation, versioned exports or training-job submission in the Enterprise docs. | Partly. Fine Tuning Studio imports datasets, trains adapters on your GPUs, evaluates them with MLflow and exports models. We did not find the equivalent integrated dataset-export and job-submission path to Baseten, Fireworks or Together AI. |
| Model serving (Can I host models on my own GPUs?) | No. The AI Gateway routes to hosted providers or to an endpoint you run. It does not serve models (AI Gateway). | No. Starburst AI connects to external providers and OpenAI-compatible endpoints (configure Starburst AI). | Yes. The Cloudera AI Inference service serves NVIDIA NIM and Hugging Face models, with fractional GPU allocation (release summary). |
| Data science workbench (Do I get notebooks, experiments and a model registry?) | Partly. Notebooks on Quanton, without experiment tracking or a model registry (notebooks). | No. The built-in interfaces are the query editor and the AI Data Assistant. | Yes. Cloudera AI Workbench with projects, sessions, ML runtimes and a model registry (release notes). |
Feature highlights
The tables say what each product can do, but they say little about how much of the work lands on your team. This section walks through the differences we think matter most once the platform is running in your own data center.
What runs underneath
Starburst Enterprise and Onehouse can both run as compute layers on Kubernetes against object storage, and each can also work against an existing HDFS cluster. Starburst also supports deployment on VMs through Starburst Admin. Cloudera’s Kubernetes-based Data Services, which include Data Engineering, Data Warehouse and Cloudera AI, also depend on a Base cluster running on bare metal or VMs. The Base cluster provides the storage, the Hive Metastore and Ranger, and Data Engineering requires Ozone to be enabled on it (prerequisites). Cloudera also supports external S3-compatible storage in individual services, including Data Warehouse and AI Registry. That access does not remove the Base-cluster and Ozone dependencies of a deployment that includes Data Engineering, so the team still operates that infrastructure alongside its existing object store.
Getting data in
Loading data is where the three products differ the most. Take the most common case, which is replicating an operational database into the lakehouse. Doing it well means reading the database’s change log, staging the changes somewhere durable, merging them into a table in order, handling schema changes, and compacting the small files that frequent commits leave behind. On Cloudera you assemble this from NiFi, which ships Debezium CDC processors and a PutIcebergCDC writer. Your team designs the flow, sizes a NiFi cluster for it and runs it. Onehouse runs the whole path as a managed service through OneFlow. You pick the source, the target table and whether the table is mutable or append-only. LakeLog stages the change log on your object store, so there is no Kafka cluster to operate, and backward-compatible schema changes are applied to the table automatically.
LakeLog also makes the ingestion log available as lakehouse data. Producers write events through a Confluent REST Proxy-compatible HTTP API, and LakeLog persists them as open tables on your object storage. OneFlow and other engines can read new events incrementally from those tables. For a team bringing CDC on premises, this removes a Kafka deployment from the ingestion architecture and keeps the durable log on storage the team already owns. Cloudera’s NiFi processors can also capture CDC without Kafka, but the team still operates NiFi and its persistent repositories.
Starburst Enterprise has no managed ingestion on-prem today. Starburst offers it in Galaxy and has said it is bringing it to Enterprise. What Starburst Enterprise does well is query the source database in place through one of its connectors, which avoids the copy altogether. That is a good answer when the extra query load on the source system is acceptable and you only need current data, and it leaves the loading to another tool when the data has to live on the lake.
Incremental processing across the pipeline
Onehouse offers the most complete incremental-processing stack of these three platforms, from managed ingestion through custom transformation jobs. OneFlow reads changes from lake tables and commits source checkpoints with the output. For more complex processing, Quanton runs Scala, Java and Python Spark code over the same changes, with index-aware joins and low-shuffle MERGE to update downstream tables. A pipeline can use managed Flows for its bronze-to-silver steps and custom Spark logic for its gold layer without introducing a separate execution system.
Latest-state incremental queries reduce the work when a downstream system needs the final value of a changed record. Hudi’s latest-state incremental queries return one final record per inserted or updated key over the requested time range. If a record is updated N times in that window, the consumer receives one final version. A CDC query preserves the individual changes, which is useful when every transition matters but creates more work for a consumer that only needs the final state.
That difference directly affects embedding costs. A pipeline that embeds every changed version of a document processes N versions; a latest-state incremental query supplies the final version once. Onehouse’s ingestion path merges repeated updates within a batch before calling the embedding model and refreshes only the changed content. The unchanged corpus stays untouched, and intermediate edits do not each trigger another embedding request. A change-feed consumer can achieve the same result by adding its own coalescing logic. Onehouse builds this behavior into the processing path.
Onehouse also supports Iceberg change processing through Quanton Spark jobs, so teams can use Iceberg’s Spark changelog procedures with their own transformation code. Starburst exposes Iceberg snapshot changes and Delta change feeds, but the user builds the downstream processing and checkpoint logic. Its Iceberg change function reports per-snapshot changes and excludes snapshots containing delete files. Keeping a long history available also means retaining snapshots and their metadata; Iceberg’s streaming guidance recommends regular snapshot expiration and metadata maintenance as commits accumulate. This creates a retention and catch-up constraint for continuously changing production pipelines. Iceberg’s v4 metadata-tree work targets metadata scalability, but it is not a capability of the Starburst versions compared here. Onehouse combines its Iceberg support with managed pipelines and the option of Hudi’s latest-state incremental queries.
The execution runtime determines what a team can do with those changes. PyStarburst supplies Python DataFrame syntax for work executed by Trino, and its Python UDFs run in a sandbox with restrictions on libraries and external access. Onehouse runs full Spark jobs with application code and dependencies. Cloudera also runs Spark and supports Kafka Structured Streaming, but its CDE release excludes Spark streaming with Iceberg. A streaming framework and a table format have to support the required changes together; installing both does not by itself deliver a continuous incremental pipeline.
Table maintenance
All three platforms automate table maintenance, with different capabilities and operating models. Starburst’s built-in jobs schedule Iceberg compaction, statistics collection, snapshot expiration and orphan-file cleanup, including all tables in a schema. Its UI offers recurring schedules and cron; the documented configuration does not expose commit-count triggers. Cloudera Lakehouse Optimizer supports event-triggered and scheduled Iceberg maintenance through policies that the operator configures after installing the service. Hive ACID tables also compact automatically.
Onehouse combines managed operation with incremental layout optimization. Table Optimizer maintains Hudi and Iceberg tables, including tables written by other engines. Its incremental clustering plans the partitions and files changed since the last run, with linear sorting, Z-order or Hilbert layouts. It also supports Iceberg v3 deletion vectors and variant columns with shredding. Flow-created tables receive cleaning and compaction automatically; other services are enabled per table and run on commit-count triggers or schedules. The same optimized files can be exposed to Delta readers through XTable. Onehouse operates these services as part of the same platform that ingests the data and runs the downstream jobs.
Query and federation
Starburst Enterprise has the deepest SQL federation offering of the three. It adds more than 50 connectors, built-in row filters and column masks, and Warp Speed, an indexing and caching layer that has supported on-prem S3-compatible storage since release 479-e. If the job is to put governed SQL on top of many existing databases and lake tables without moving anything, it is the most complete option here. Cloudera has moved in the same direction by adding Trino Virtual Warehouses with federation connectors next to Impala and Hive.
Postgres compatibility matters when agents need to query the lake through tools they already use. The Postgres ecosystem includes agent integrations for schema discovery and SQL queries. As those agents reach beyond application data into larger analytical datasets, a compatible endpoint lets them reuse their Postgres drivers and connection code. Onehouse’s Lakegres provides that endpoint over lake tables, with record-level and secondary indexes for selective lookups. This makes Postgres compatibility a concrete integration requirement for teams building on that ecosystem. Starburst and Cloudera also offer agent access through other interfaces, including MCP, which the AI table covers separately.
For federation, Onehouse uses managed Trino clusters under Open Engines. Starburst Enterprise remains the deeper option for a team whose main job is joining across many source systems.
Who operates the platform
Starburst Enterprise and Cloudera are software that you install and run. You get Helm charts or Cloudera Manager, a license and vendor support, and your team owns upgrades, scaling and incidents. Both can run without an outbound network connection, and Cloudera documents an air-gapped install. The standard Onehouse deployment is split into a data plane on your Kubernetes cluster and a control plane that Onehouse hosts (bring your own Kubernetes). Onehouse installs, upgrades and operates the data plane remotely, and the data plane needs outbound access to reach the control plane. Your data stays in your own storage. The benefit is that a team without a platform engineering group can get a lakehouse without staffing one. Air-gapped operation is technically possible with a custom control-plane deployment, which Onehouse considers on a case-by-case basis; it is not supported out of the box.
The AI data layer connects retrieval, agent runs and training
The integrated AI data layer is Onehouse’s clearest feature advantage in this comparison. It brings the data work across an agent’s lifecycle into one platform, from keeping retrieval data current to turning scored agent runs into training datasets. OneFlow turns structured sources and unstructured files into open tables and keeps embeddings current through incremental processing. Lakegres serves analytical SQL, indexed record lookups, full-text search and vector search over those tables through a Postgres-compatible endpoint. The semantic layer supplies certified metrics and dimensions for natural-language questions, with generated SQL running under the asking user’s permissions. An agent can retrieve a document, look up the associated customer and ask about a business metric against the same governed data.
The AI Gateway governs the models and tools that agents call. Model routing includes provider credentials, stable aliases, fallbacks, traffic splitting and user or group permissions, with no Onehouse charge on token volume. Tool governance is a separate capability: the gateway combines Onehouse’s MCP server with external servers for systems such as GitHub, wikis and ticketing tools. Agents connect to one endpoint, while the gateway applies group permissions to tools and brokers credentials. Starburst also governs external MCP servers inside AIDA, but its permissions apply to whole servers. Cloudera’s Agent Studio selects tools for its agents, while approved-server policies and network enforcement remain the operator’s responsibility.
Agent runs become reusable data in Onehouse. Gateway calls are logged with their run, latency and estimated spend, and applications can send traces directly through OpenTelemetry or Langfuse even when their calls bypass the gateway. These traces land in mutable Iceberg tables on your storage. A judge can add scores or labels later, and evaluation pipelines can join those runs to business outcomes, read earlier versions and process new or updated records incrementally. You control retention, so older successes and failures remain available for the next evaluation or training dataset. Starburst records its agent sessions and exports query traces; Cloudera provides Phoenix-based workflow monitoring. Neither documented path provides this integrated trace-to-lake-table workflow.
Quanton prepares the datasets used to improve models. Spark and Python jobs join agent runs with business data, select useful examples, run batch inference for classification or extraction, and produce validated, versioned exports. Onehouse submits training jobs to open-model providers Baseten, Fireworks and Together AI and tracks their status; those providers perform the training. Supervised fine-tuning (SFT) teaches a model from example responses, using message or prompt/completion datasets. Supported exporters also handle preference pairs and raw text. Reinforcement fine-tuning (RFT) uses reward feedback to improve model behavior; Onehouse’s scored traces and versioned business context supply data that evaluation and reinforcement-learning environments can consume. Quanton handles the data preparation, with the training method and execution handled by the chosen provider or your own training system.
Cloudera remains the option here for teams that want the platform to run model training and serving on their own GPUs. Its Fine Tuning Studio trains adapters and evaluates them with MLflow, alongside AI Inference and a data science workbench. Starburst’s AI features center on governed SQL, data products, its assistant and model calls from SQL. Onehouse’s advantage is the integrated data path: the same platform ingests and maintains the data, serves agent queries, governs model and tool access, and turns scored agent activity into reproducible inputs for the next training run.
How to choose
The three products overlap less than a three-column table suggests, so the choice mostly comes down to which part of the work you need help with. Starburst Enterprise is the natural fit when your data already sits in databases and lake tables and you need governed SQL across all of it. Cloudera covers the most ground when you need a self-contained, air-gapped stack that includes storage and model serving, and you have the team to run it. Onehouse fits when the hard part is getting data out of databases, streams and files into open tables and keeping those tables in good shape on storage you already own, and you would rather not operate the platform yourself. For teams building AI agents, its integrated data layer also connects retrieval, governed model and tool access, and reusable evaluation and training data on the same lakehouse.
Using two of them together is also a reasonable design. Onehouse and Starburst Enterprise can work on the same Iceberg tables in the same object store, with Onehouse writing and maintaining the tables and Starburst serving queries and federation. Both can also run against an existing Cloudera HDFS cluster, which lets a team move workloads over one at a time.
Performance
Onehouse pulls ahead on both data processing and interactive SQL in the published workloads below. Quanton accelerates Spark reads, transformations and incremental writes; Lakegres extends that engine to interactive SQL, with measured gains over Presto and Trino on the cited workloads.
Quanton delivered a 4.4x speedup over open-source Spark in NetApp’s on-premises validation. On the 1 TB TPC-DS workload, it completed the suite in 795 seconds versus 3,489 seconds for open-source Spark on the same StorageGRID-backed Kubernetes environment. That takes the aggregate runtime from roughly 58 minutes to 13 minutes on infrastructure in a data center. NetApp also validated Iceberg MERGE pipelines and continuous table maintenance on StorageGRID (NetApp validation).
The gains extend to interactive SQL through Lakegres, which uses Quanton for query execution. In a separate comparison in the same NetApp validation, Lakegres completed the 1 TB TPC-DS workload in 865 seconds versus 1,378 seconds for Presto, using the same five-worker configuration. That is 37% lower aggregate query runtime, or about 1.6x faster. Onehouse can accelerate Spark transformations and serve interactive queries against the same on-premises lakehouse storage.
We have also published a production comparison with Trino. On a customer’s 99-query Iceberg workload, Lakegres delivered a 4.9x median query speedup, with 98 of 99 queries faster. This is a separate customer result; the post does not specify hardware, engine versions or deployment location.
Quanton’s broader benchmarks show acceleration across both transformations and incremental writes. On AWS, the 10 TB TPC-DS suite completed in 2,034 seconds versus 12,200 seconds for open-source Spark, a 6x speedup on the same 11-instance configuration. A separate 1 TB LakeLoader dimension-table workload measured a 4.1x speedup for loading and updating data. Quanton combines native columnar execution with storage-aware query planning, indexed joins and low-shuffle merges, so the engine can reduce both execution time and the amount of data a pipeline has to process (engine architecture).
Each result applies to its stated workload and baseline. A direct Starburst Enterprise or Cloudera performance comparison requires running those distributions in the same setup. For an on-premises evaluation, our published methodology and benchmark instructions provide a starting point: measure query runtime, incremental writes and table maintenance on the hardware and storage you will operate. Include the selective lookups and concurrent queries your agents need alongside the larger analytical queries.
Sources and method
Product facts come from each vendor’s public documentation, reviewed through November 16, 2026. We read the Starburst Enterprise 483-e docs and release notes, the Cloudera Base 7.3.2 and Data Services 1.5.5 SP4 docs, Flow Management 4.13 and Streaming Analytics 1.18 where cited, and the Onehouse platform guide. Where a cell says we did not find something, the capability is absent from the pages we read, and it may exist under another name. Corrections are welcome at gtm@onehouse.ai.
Author

Vinoth Chandar
CEO
Onehouse founder/CEO; Original creator and PMC Chair of Apache Hudi. Experience includes Confluent, Uber, Box, LinkedIn, Oracle. Vinoth's work spans relational databases at Oracle, distributed NoSQL systems at LinkedIn, streaming systems with Kafka and kSQL at Confluent, and the invention of the lakehouse architecture with Apache Hudi at Uber. At Onehouse, he is pushing lakehouse architecture further with the Quanton execution engine and Lakegres. He is now building the database for AI.





































































































































