Open Table Formats: Apache Iceberg, Delta Lake and Hudi
Open table formats explained: how Apache Iceberg, Delta Lake and Hudi add ACID transactions, time travel, schema evolution and compaction to data lakes.
Open table formats such as Apache Iceberg, Delta Lake and Apache Hudi turn a folder of data files on object storage into a real table. They track exactly which files belong to each version of the table in metadata, so writes become atomic commits, readers always see a consistent snapshot, schemas can evolve safely, and you can query the table as it was yesterday. They're what makes a lakehouse possible.
The problem with plain files
- No atomicity: a job writing 500 files fails after 300; readers now see a partial table.
- No isolation: a reader listing files during a write sees some old and some new files.
- Slow planning: listing millions of files on object storage just to plan a query is slow and costly.
- No safe updates or deletes: changing one row means rewriting files with no coordination, which matters for corrections and privacy deletion requests.
- Fragile schema changes: renaming or reordering a column can silently misalign old files.
How a table format works
The table's state is a chain of snapshots described by metadata files. Each snapshot lists the data files that make up the table at that moment, with per-file statistics. A writer creates new data files, writes new metadata describing the next snapshot, then atomically swaps the catalog's pointer to that metadata. If two writers race, one commit wins and the other retries on top of it (optimistic concurrency).
Delta Lake records the same information as an ordered transaction log of JSON commits with periodic checkpoints. Hudi uses a timeline of actions. The mechanisms differ, but all three give atomic commits and snapshot reads.
What you get
| Capability | What it means | Why it matters |
|---|---|---|
| ACID commits | A write is all or nothing; concurrent writers are serialised | Retries and failures never leave half-written tables |
| Snapshot isolation | Readers see one complete version | Dashboards don't see partial loads |
| Time travel | Query AS OF an earlier snapshot | Debugging, reproducible ML training sets, audits |
| Schema evolution | Add, drop, rename and reorder columns by ID, not position | Producers can change without breaking old files |
| Row-level changes | MERGE, UPDATE and DELETE | CDC upserts, corrections, privacy deletion |
| File-level statistics | Min/max per column per file in metadata | Prune files without listing storage |
Copy-on-write vs merge-on-read
| Copy-on-write | Merge-on-read | |
|---|---|---|
| On update | Rewrite affected data files with changes applied | Write small delete or delta files alongside the data |
| Write cost | Higher | Lower |
| Read cost | Lower: files are already final | Higher: readers merge deltas until compaction |
| Good for | Read-heavy tables, infrequent updates | Frequent upserts and streaming CDC |
Operating them
- Compaction: rewrite many small files into fewer large ones (see the small files problem), and fold merge-on-read deltas into base files.
- Snapshot expiry: old snapshots keep old files alive; expire them on a schedule, which also sets how far back time travel works.
- Orphan file cleanup: remove files left behind by failed writes.
- Catalog choice: the catalog (Hive metastore, a REST catalog, or a managed one) is the source of truth for the current table version and the place to apply access control.
- Deletion requirements: a DELETE removes rows from the current snapshot, but data stays in old files until snapshots expire and files are cleaned up.
Choose by ecosystem more than features: which engines and catalogs your team already uses, and which format they support best. The core guarantees are similar.
Where it’s used
Database changes are merged into Iceberg or Hudi tables continuously, keeping a queryable copy of operational data.
A training job records the snapshot ID it read, so the exact dataset can be reloaded later.
Row-level deletes plus snapshot expiry remove a user's data from the lake within a deadline.
In an interview
- Explain that the format adds a metadata layer with atomic snapshot swaps over immutable files.
- Mention time travel for debugging and reproducibility.
- Choose copy-on-write or merge-on-read from the update pattern.
- Include compaction and snapshot expiry in the operating plan.
Further reading
- Apache Iceberg specificationApache Software Foundation
- Delta Lake documentationDelta Lake (Linux Foundation)
- Apache Hudi conceptsApache Software Foundation