What actually changes about your day when you pick Iceberg over Delta Lake instead of Hudi? Not the marketing slides. The real answer lives in the unglamorous parts of the job: how you run an upsert at 2 a.m., how you roll back a bad batch, how a second engine reads the same table, and how much of your catalog you end up maintaining yourself.
By 2027 these three open table formats have converged enough that the choice is less about file layout and more about workflow. That shift is what this breakdown covers.
Why the Format Wars Settled Into Workflow Wars
All three formats solve the same core problem: they put a metadata layer over Parquet files on object storage so you get ACID transactions, schema evolution, and time travel without a traditional warehouse. The data files look similar. The metadata models do not.
Hudi started at Uber and entered the Apache Incubator in 2019. Delta Lake launched at Databricks in April 2019 and was donated to the Linux Foundation that October. Iceberg came out of Netflix, entered the Apache Incubator in November 2018, and graduated alongside Hudi in 2020. Those origins left fingerprints. Hudi was built for incremental ingestion pipelines. Delta was built to make Spark reliable. Iceberg was built to be read by many engines. (Apache Iceberg)
That history explains a pattern many teams hit in practice: the format you pick tends to match the engine you already trust. If that sounds familiar, it is the same trap people fall into with note-taking tools, where the workflow you already have beats the feature list you admire. The Obsidian vs Logseq local-first notes comparison by workflow makes the same point for personal knowledge tools.
The Metadata Model Is the Real Difference

Before comparing features, understand what each format writes to storage. Everything else follows from this.
| Format | Metadata mechanism | What it means for you |
|---|---|---|
| Apache Iceberg | Catalog plus manifest files and snapshots | The catalog becomes a first-class dependency you must operate |
| Delta Lake | A `_delta_log` transaction log (JSON plus Parquet checkpoints) | Self-contained on storage, which simplifies setup but ties history to that directory |
| Apache Hudi | A timeline of instants plus table metadata | Built around commit events, which suits incremental consumers |
The Iceberg approach is the most portable and the most operationally demanding. You need a catalog, whether that is a REST catalog, Hive, Nessie, or a cloud service. The Delta approach is the easiest to stand up because the log lives next to the data. The Hudi approach is the most pipeline-friendly because the timeline is designed to be queried.
A common mistake: teams pick a format based on benchmark blog posts, then discover six months later that their catalog choice, not the format, is what limits them. Decide who owns the catalog before you decide the format.
Upserts, Deletes, and the Write Path
This is where the formats feel most different in daily work.
Hudi’s core design centers on upserts and incremental pulls, using copy-on-write and merge-on-read tables with built-in indexing options. If your job is “land changes from a source system every fifteen minutes and keep a clean table,” Hudi was built for exactly that, and the Apache Hudi documentation on table types and upserts walks through the copy-on-write versus merge-on-read tradeoff in detail.
Iceberg handles row-level deletes through position and equality delete files introduced in its v2 spec, combined with merge-on-read behavior. Deletes are explicit objects in the table, which is powerful for compliance work but means readers must apply them. The Apache Iceberg table specification is worth reading once, carefully, because it explains why some queries suddenly slow down.
Delta Lake uses deletion vectors for merge-on-read deletes, added in Delta 2.3 in 2023. For most Spark-centric teams, upserts feel native because the write path was designed around Spark from day one.
Practical guidance that holds up: benchmark your own upsert pattern with your own data skew. Vendor benchmarks rarely match production because they rarely include your worst partition.
Multi-Engine Access and the Catalog Problem
This is the workflow difference that bites hardest in 2027, because most organizations now run at least two query engines.
Iceberg has the broadest engine support, spanning Spark, Trino, Flink, Presto, Snowflake, and BigQuery through BigLake. That breadth is the whole point of the format, and it is why open catalog specifications matter so much. The Iceberg REST catalog specification exists so that different engines can agree on where tables live and what they contain.
Delta’s cross-engine story improved with Delta Lake 3.0 and the Delta Universal Format, announced in 2024, which lets Delta tables be read as Iceberg and Hudi tables. Treat that as a vendor claim until you test it against your own readers. UniForm is genuinely useful, but “readable as” is not the same as “fully featured as.”
Hudi is often paired with cloud data platforms such as Amazon EMR and Google Cloud services, and its Flink and Spark Structured Streaming sinks are a real strength for streaming ingestion.
One trap worth naming: a table can be readable by four engines and still be painful to write from three of them. Read support and write support are different problems. Map both before committing.
Time Travel, Incremental Reads, and Change Data
All three formats support time travel through snapshots or versions, but the ergonomics differ.
Delta Lake exposes table history through `DESCRIBE HISTORY` and offers a change data feed, introduced around 2021, for reading row-level changes between versions. The Delta Lake batch and time travel documentation covers the syntax and the limitations.
Hudi emphasizes incremental queries, letting downstream jobs pull only records changed since a given commit. If your architecture is a chain of incremental jobs rather than nightly full refreshes, this is a meaningful workflow advantage.
Iceberg supports incremental scans through its API, though the experience depends on the engine you use. A team running Trino will have a different experience than a team running Spark.
Here is the honest advice: if you need change data capture as a first-class daily workflow, test all three with a real downstream consumer. The gap between “supports incremental reads” and “supports incremental reads well in my engine” is where projects stall.
Governance, Interoperability, and What 2027 Actually Looks Like
The formats have been converging. UniForm, Iceberg-compatible readers, and open catalog projects all point in the same direction. That convergence is analysis, not a guarantee, but the trend is visible in how vendors talk about their formats.
The practical consequence is that format choice is becoming less decisive and catalog, engine, and governance choices are becoming more decisive. If your organization already has a strong catalog strategy, the format question mostly answers itself.
Storage and workspace tooling follow the same logic. Teams that pick tools by workflow rather than feature checklists tend to stay happy longer, which is the argument behind this breakdown of Dropbox alternatives chosen by use case. The same reasoning applies to how you choose a Google Drive alternative that fits your workflow instead of the loudest option.
For AI-assisted work on top of these tables, a practical Claude writing workflow is a useful reminder that tooling discipline beats tooling novelty. And if you are weighing assistants themselves, this roundup of Claude alternatives by workflow and price covers the tradeoffs.
A Decision Checklist That Actually Works
Skip the benchmark charts. Run this instead.
- List every engine that must read the table and every engine that must write to it. Separate the two lists.
- Name the catalog you will operate and who owns it on call.
- Write down your upsert frequency and your worst-case data skew.
- Identify whether downstream consumers need incremental reads or full refreshes.
- Test a rollback and a schema change on real data before you commit.
- Confirm your retention and deletion requirements map to how each format stores deletes.
Teams that do this in a week usually avoid a year of rework. Teams that skip it usually discover the catalog problem in month seven.
Conclusion
The Iceberg versus Delta Lake versus Hudi question in 2027 is less about which format is best and more about which workflow you are willing to operate. Iceberg rewards teams that invest in a catalog and want broad engine access. Delta Lake rewards teams already deep in Spark that want the simplest possible setup. Hudi rewards teams whose core problem is incremental ingestion and upserts.
Pick the workflow you can run on a bad Tuesday, not the one that wins a benchmark on a good one.
FAQ
Is Apache Iceberg better than Delta Lake?
Neither is universally better. Iceberg offers broader multi-engine support and a catalog-driven model. Delta Lake offers simpler setup and tight Spark integration. The right answer depends on your engines, your catalog ownership, and your write patterns.
Which format is best for upserts and streaming ingestion?
Hudi was designed around upserts and incremental pulls, with copy-on-write and merge-on-read table types plus built-in indexing. It is often the strongest fit for frequent upserts. Iceberg and Delta both handle upserts well, but test with your own data skew before deciding.
Do I need a catalog to use Apache Iceberg?
In practice, yes. Iceberg uses a catalog such as REST, Hive, Nessie, or a cloud service to track tables, alongside manifest files and snapshots. That catalog is an operational dependency you must plan for, staff, and monitor.
What is Delta Universal Format and does it remove lock-in?
Delta Universal Format, announced in 2024, lets Delta tables be read as Iceberg and Hudi tables. It improves interoperability, but treat vendor claims carefully. Readable as another format is not the same as fully featured in that format, so test with your actual readers.
Can all three formats handle time travel?
Yes. Iceberg uses snapshots, Delta Lake uses its transaction log and table history, and Hudi uses its timeline of instants. The syntax and the engine support differ, so confirm the experience in the engine your team actually uses daily.
How should a team choose between these formats in 2027?
Start with the engines that must read and write the table, then name the catalog owner, then test upserts, rollbacks, and schema changes on real data. Format differences matter less than catalog, engine, and governance choices. Run the test before you commit.
The convergence trend also changes how you should think about migration. If you start on Delta and later need broader engine access, UniForm may buy you time, but it does not move your history, your governance policies, or your catalog ownership. Plan migrations as catalog projects with a format change attached, not the reverse. Budget for a parallel-run period where both tables are written and compared, because silent divergence in delete handling or schema evolution is the failure mode that erodes trust fastest. Document who can approve schema changes and how deletes propagate to downstream consumers before the first production write, not after the first incident. Finally, revisit the decision annually. The formats are converging, but the operational surface around them — catalogs, engines, and governance tooling — is still moving quickly, and a choice that fit your stack in 2025 may not fit it in 2027. The teams that stay comfortable are the ones that treat the format as one component in a workflow they own, review, and can explain on call. That is the real lesson: the format is a detail, the workflow is the product.


