Which table format fits a self-hosted lakehouse, Iceberg or Delta Lake?
Choose Apache Iceberg first when several engines must read and write the same tables and the catalog should stay a separate, deliberate choice. Iceberg is an Apache-2.0 table format from the Apache Software Foundation, built for huge analytic tables that Spark, Trino, Flink, Presto, Hive and Impala can work with at the same time. Trino's Iceberg connector accepts Hive Metastore, AWS Glue, JDBC, REST, Nessie and Snowflake catalogs, selected through iceberg.catalog.type. A platform team can therefore pick the catalog for operational reasons and keep the table format stable. Review the Trino Iceberg connector documentation before you commit to a catalog.
Choose Delta Lake when Spark drives most of the pipeline work or the team already runs Databricks, where Delta is the default format for all tables. Delta Lake is also Apache-2.0 licensed and has been a Linux Foundation sub-project since 2019, with a published charter and no single controlling company. The Trino connector is listed in the Delta Lake README, but the Flink connector is labeled as a preview that writes to Delta Lake, so confirm its maturity for your write path. UniForm (Delta Universal Format) lets Iceberg and Hudi clients read Delta tables, which can serve read-only consumers. Confirm which clients and versions those consumers use before relying on UniForm for production reads.
Four drivers should settle the decision: the engines in use now and over the next two years, the catalog your team can operate, the write patterns (batch appends, merges and streaming upserts), and the migration path from existing tables. If Trino is the main query layer and Spark writes most of the data, test both formats with your own merge, time-travel and rollback queries. Trino currently supports Iceberg format versions 1 and 2, with version 3 listed as experimental, so check the format version each engine supports before you standardize on a table format for the whole platform.
Which scenarios favor Iceberg and which favor Delta Lake
This table maps common self-hosted lakehouse setups to the table format that usually fits best, with the condition that makes each choice sound. Read each row as a starting point: if the stated condition does not hold in your environment, the other format may be the safer choice.
| Scenario | Better fit | Reason and condition |
|---|---|---|
| Trino-first analytics on self-hosted storage | Iceberg | Trino's Iceberg connector reads and writes Parquet, ORC and Avro, supports time travel, schema evolution and MERGE, and works with Hive Metastore, AWS Glue, JDBC, REST, Nessie and Snowflake catalogs. Choose Delta Lake instead if you need the Trino Delta Lake connector for existing Delta tables, which is already listed among its connectors. |
| Spark-first pipelines with batch and streaming | Either, depending on existing tables | Both formats are workable from Spark. Delta Lake's transaction log and merge, update and delete operations are a natural fit when Spark is the main writer. Confirm the Spark and format versions you will run, since the Iceberg and Delta Lake release lines move independently. |
| Mixed engines that include Flink | Iceberg | Iceberg is designed so several engines, including Spark, Trino, Flink, Presto, Hive and Impala, work on the same tables at the same time. Delta Lake's Flink connector is listed as a preview that writes to Delta Lake, so confirm its current maturity before relying on it for production writes. |
| Databricks already in use | Delta Lake | Databricks makes Delta Lake the default format for all tables on its platform, so Delta Lake avoids conversion work and keeps governance and tooling consistent. If you also need Iceberg readers, UniForm lets Iceberg and Hudi clients read Delta tables, but confirm how it behaves for your write patterns and engine versions. |
| Cloud warehouses reading the same tables | Iceberg (confirm per platform) | Snowflake stores Iceberg tables and external engines can read them through its Horizon Iceberg REST Catalog API. Microsoft OneLake can expose Delta tables to external Iceberg readers. Confirm which warehouse read and write paths your team needs, because support differs by platform and by table mode. |
| Governance and vendor neutrality as the main criteria | Either, judged on governance | Iceberg is an Apache-2.0 project under the Apache Software Foundation. Delta Lake is Apache-2.0 licensed and described by delta.io as a Linux Foundation sub-project with a published charter. Both are open. Choose by which foundation's process and maintainer base your architecture board trusts most. |
| Time travel and rollback needs | Either, check the engine | Iceberg lists time travel to exact snapshots and rollback as core features, and Amazon Athena engine version 3 supports time travel clauses for Iceberg. Delta Lake offers time travel to earlier table versions. Confirm the syntax and retention behavior in the engines you will query. |
| Small team with one engine and no multi-engine plans | Either, favor the existing stack | Switching formats later costs migration effort, so the strongest reason to pick a format is the engine you already run. If the current platform writes Delta or Iceberg, staying on it usually lowers implementation effort. Ask your implementation partner to estimate the migration scope in writing. |
How Iceberg and Delta Lake organize metadata, catalogs and engines
Both formats keep table state in files beside the data, so the choice shows up in where that state lives and who must keep it available. Iceberg relies on a catalog to point engines at the current metadata, while Delta Lake records each change in a transaction log. The cards below cover what each design means for catalog uptime, log upkeep and engine behavior on Trino and Spark.
Iceberg metadata and catalog pointer
Iceberg tracks each table through metadata files and snapshots, and a catalog holds the pointer to the current metadata file. Engines commit by moving that pointer, so the catalog is on the write path and must stay reachable for every engine that reads or writes the table. Confirm with your catalog vendor how commits behave during a catalog outage and whether the catalog is a single point of failure in your design.
Delta transaction log
Delta Lake extends Parquet data files with a file-based transaction log stored alongside the table, so the table's history travels with its files. Readers and writers coordinate through that log without a separate catalog service being mandatory for every operation. Confirm with your Delta engine versions how the log is checkpointed and vacuumed, because log growth and cleanup are the main operational tasks on this side.
Iceberg catalog types in Trino
Trino's Iceberg connector selects its catalog with iceberg.catalog.type and supports Hive Metastore, AWS Glue, JDBC, REST, Nessie and Snowflake. Each choice sets who runs the catalog service, how it is backed up and which other engines can reach it. Check the catalog type against every engine on your shortlist before committing, because a catalog that one engine cannot reach removes the shared-table benefit.
Delta log access from other engines
Delta Lake lists Spark, Trino, Flink, Hive, Snowflake and other engines as working with the format, and the Delta Lake README describes a Trino connector and a preview Flink connector that writes to Delta Lake. Connector maturity differs by engine and version, so the same table may behave differently across Trino and Spark. Confirm write support, merge behavior and log handling for each engine version you plan to run.
Log and metadata maintenance
Iceberg needs snapshot expiration and orphan file cleanup, while Delta Lake needs log checkpointing and file cleanup, and both grow metadata with every write. Neglected maintenance slows planning and increases storage cost on either format. Ask each vendor or your platform team which maintenance jobs run on a schedule, who owns them and how they are tested before production.
Catalog availability and recovery
Because Iceberg depends on a catalog for commits and reads, the catalog's backup, failover and access control decide how quickly tables recover after an incident. Delta tables can be read from storage paths, but multi-engine governance still needs a shared access layer. Confirm restore procedures for the catalog and the object store together, and test that a restored catalog points to the same table state as the data.
Side-by-side capabilities for Trino, Spark and self-hosted operations
This table compares the two formats on the points that shape a self-hosted lakehouse: governance, format versions, Trino write and time travel support, catalogs, engine lists and operating requirements. Read each row against your own engines, and treat any cell marked for confirmation as an open question for the engine documentation before you commit.
| Capability | Apache Iceberg | Delta Lake |
|---|---|---|
| License and governance body | Apache License 2.0, developed under the Apache Software Foundation | Apache License 2.0 repository; Delta.io states it is a Linux Foundation sub-project since 2019 under a published charter |
| Spec or protocol versions | Trino reads and writes format versions 1 and 2; version 3 is experimental in Trino | Latest supplied release is Delta Lake 4.4.1 (October 5, 2026); confirm protocol reader and writer versions for your engines |
| Time travel | Supported in Trino's Iceberg connector; Athena engine version 3 also supports it | Supported; Delta.io lists time travel to earlier table versions |
| Schema evolution | Supported in Trino and listed as a core Iceberg feature without table rewrites | Schema enforcement is listed; confirm which schema changes each engine applies |
| DELETE and MERGE in Trino | INSERT, UPDATE, DELETE and MERGE are supported in the Trino Iceberg connector | Trino's Delta Lake connector reads and writes; confirm the exact DML statements supported in your Trino version |
| Catalog choices | Trino supports Hive Metastore, AWS Glue, JDBC, REST, Nessie and Snowflake catalogs | Catalog options depend on the engine; confirm which catalogs your Trino and Spark setup can share |
| Engine support lists | Spark, Trino, Flink, Presto, Hive and Impala are named by Apache Iceberg | Spark, PrestoDB, Flink, Trino, Hive, Snowflake, BigQuery, Athena, Redshift, Databricks and Azure Fabric are listed |
| UniForm interoperability | Not applicable as a Delta feature; confirm how Iceberg readers reach Delta tables in your stack | UniForm lets Iceberg and Hudi clients read Delta tables; confirm the write path and version support with Delta |
| Trino fault-tolerant execution | Off by default; QUERY or TASK retry policy must be enabled, and TASK needs an exchange manager on S3, Azure Blob, GCS or HDFS | Same Trino requirements apply to any Trino query, regardless of table format |
What licensing and governance mean for each format
Apache Iceberg is licensed under the Apache License 2.0 and is developed under the Apache Software Foundation, so its governance follows the ASF model of open development and community decision-making. The main repository holds the Java reference implementation, and separate implementations exist for Python (PyIceberg), Go, Rust and C++, which matters if your ingestion or tooling is not JVM-based. Because the specification and reference code are open, a self-hosted team can run Iceberg tables without buying a paid edition of the format itself.
- License: Apache License 2.0 applies to the format's main repository, which permits commercial use, modification and redistribution under its terms.
- Stewardship: The Apache Software Foundation governs the project, with decisions made in public by its contributors and committers.
- Language coverage: PyIceberg, Go, Rust and C++ implementations exist alongside Java, so check that each one you need meets your feature requirements.
- Paid editions: The supplied facts identify no paid edition of the Iceberg format. Managed services that read or write Iceberg, such as Snowflake, OneLake, Athena and Databricks, are separate products with their own terms.
- Release line: The Iceberg documentation lists 1.12.0 as the latest release, so confirm the version your engines support before you standardize on it.
Before committing, confirm with each vendor which Iceberg format version and catalog features its managed service exposes, because those terms are set by the product, not the specification.
Delta Lake is released under the Apache License 2.0 and has been a Linux Foundation sub-project since 2019. Delta.io states that it is an independent open-source project not controlled by any single company and that it follows a published charter. Databricks documentation states that Databricks originally developed the Delta protocol, continues to contribute, and makes Delta the default format for all tables on Databricks. That history means the protocol and the commercial platform share a common origin, so self-hosted teams should check how much of the roadmap and tooling is driven by Databricks.
- License and foundation: Apache License 2.0 for the delta-io/delta repository, under Linux Foundation stewardship as a sub-project since 2019.
- Charter: Delta.io points to a published charter that governs how the project is run, which you should read before relying on its governance claims.
- Original developer: Databricks developed the protocol originally and remains a contributor, so confirm which features land first in open source versus the Databricks runtime.
- Paid editions: The supplied facts identify no paid edition of the Delta Lake format. Databricks is a separate commercial product, and Snowflake, OneLake, Athena and BigQuery are separate platforms to confirm for their Delta support.
- Release line: Delta Lake 4.4.1 was published on October 5, 2026, after 4.4.0 on August 20, 2026, so verify compatibility with your Spark and Trino versions.
Ask for the Delta charter text and the contributor breakdown when you evaluate governance, and confirm any Databricks-only features you would depend on.
Trino is the distributed SQL query engine both table formats are commonly read through in a self-hosted lakehouse. Trino is licensed under Apache-2.0 and its README describes it as a fast distributed SQL query engine for big data analytics, formerly known as PrestoSQL. Its Iceberg connector and Delta Lake connector are separate pieces of software with their own feature lists, so the format choice also determines which connector behavior you depend on. Trino does not store your data itself: it reads through connectors, so you still need object storage and a table catalog.
- License: Apache-2.0 for the trinodb/trino repository, which is separate from the licensing of the table formats it reads.
- Connector scope: The Iceberg connector supports Iceberg format versions 1 and 2, with version 3 listed as experimental, and includes time travel, schema evolution and MERGE.
- Delta support: The Delta Lake connector reads and writes Delta tables, so a Delta-first design still works with Trino, though feature parity should be tested.
- Release cadence: Trino release 484 was published on October 15, 2026, after releases 483 and 482, so plan your upgrade process around a fast cadence.
- Governance of the engine: Trino's security docs describe authentication and access control options, including Apache Ranger and Open Policy Agent, which you should map to your own policy model.
Before you choose a format, confirm the exact Trino connector features you need for your format version and write operations in a test cluster.
What drives the running cost of an Iceberg or Delta lakehouse
The running cost of either format is set less by the format itself than by the components around it: object storage for Parquet data and metadata files, compute for each engine that reads or writes tables, the catalog service that tracks the current table pointer, and the staff hours spent on table maintenance and upgrades. Object storage and compute recur monthly and scale with data volume and query load. The catalog is usually a small service, but it is a dependency for every engine, so its hosting, backup and access control belong in the cost model. Trino needs a separate table catalog such as an Iceberg REST catalog or Hive Metastore because it does not store tables itself, and Spark, Flink and Trino clusters each carry their own compute bill. Ask any vendor or integrator to price each of these lines separately, with the assumed cluster sizes and retention periods written down.
Migration is the largest one-time cost: converting or rewriting existing tables, validating row counts and schemas, repointing jobs, and retraining staff on maintenance procedures. Recurring work is different. Both formats accumulate small files and old snapshots or log entries, so someone must schedule compaction, expire snapshots and remove orphan files. Write frequency is the main driver here. Frequent small commits from streaming jobs create more metadata and more maintenance, while batch loads that commit less often are cheaper to run. The number of engines is the second driver, since each engine adds connector upgrades, permission rules and testing against both format versions. Catalog choice is the third, because a managed catalog shifts operations work to a vendor fee, while a self-hosted catalog moves that work onto your platform team. When you request a quote, ask for a written split of one-time and recurring items, the named maintenance jobs and their schedules, the engines in scope with their connector versions, and the catalog hosting model. Ask who carries upgrade testing when Trino releases or Delta and Iceberg versions change, and what evidence of backup and restore testing the catalog will have. Confirm licensing for any managed platform, because Databricks-hosted Delta and Snowflake-managed Iceberg tables carry platform fees that a self-hosted stack does not. Any figure you receive should be traceable to a stated scope, not to a flat estimate.
How to move tables between Iceberg and Delta Lake without losing history
This sequence moves tables from one open table format to the other while keeping the history readers depend on, such as time travel and schema changes. It ends with writers on one format, a documented catalog, and the old path retired.
Inventory tables, writers and readers
The platform owner lists every table in scope, its current format and location, the engines that write to it (for example, Spark jobs) and the engines that read it (for example, Trino queries, BI dashboards and Athena). Record which tables rely on time travel, which have schema changes in their history, and which orchestration jobs touch them. Done means every table has a row in the inventory with a named owner and a list of consumers that must keep working after cutover.
Choose the target catalog and access model
Pick the catalog that will hold Iceberg table metadata, such as a Hive Metastore, AWS Glue, a JDBC or REST catalog, or Nessie, and confirm that every engine on the inventory can reach it. The Trino Iceberg connector supports several of these through its catalog type setting, so check the connector documentation for each engine's current support. Decide where authentication and table-level access policies will be enforced before any data moves. Done means a written catalog decision and a test connection from each engine.
Choose conversion, UniForm read access or rebuild
For each table, decide between three paths: convert the existing table so the data files and history carry over, use Delta UniForm so Iceberg clients can read the Delta table while writers stay on Delta, or rebuild the table by reloading data into a new Iceberg table. Conversion keeps the most history but depends on tooling that must be confirmed against current Delta Lake and Iceberg engine documentation. Rebuilds lose history older than the reload unless you keep the source. Done means each table has a recorded path and a reason.
Migrate data files and verify what transferred
Run the chosen path on a copy of one representative table first. Confirm that row counts, partitioning and column types match the source, and that the schema history is visible in the target. Check which snapshots or versions carried over, since tooling support for historical state varies by path and engine version. Done means a signed-off comparison report for the test table, with any gaps recorded as known limits.
Validate time travel and schema history
Query the migrated table at a historical point that existed in the source, using the time travel syntax of each engine that must support it, and compare results with the source at the same point. Confirm that schema changes appear in the expected order and that a rollback to an earlier state behaves as documented. Athena engine version 3 and Trino both expose time travel, but confirm syntax and behavior against each engine's current documentation. Done means every table with a retention requirement has a recorded pass or an accepted exception.
Rebuild catalog, policies and jobs
Recreate the parts of the platform that do not move with the data: catalog configuration on each engine, access policies in Ranger, OPA or file-based rules, dashboards that point at the new tables, and orchestration jobs that read or write them. Update connection strings and secrets in each service. These items are manual work, so assign an owner to each and track them against the inventory. Done means every consumer in the inventory reads the new table through the new catalog with the intended permissions.
Cut over writers and retire the old path
Pause writes to each table, run a final incremental load to close the gap, then point writers at the new format. Keep the old table read-only for a period agreed with the data owners before deleting it, so rollback stays possible. Remove the old catalog entries and access rules once no consumer references them. Done means writers and readers use only the target format, a backup of the retired table is confirmed, and the old path is documented as closed.
Where implementation projects on either format usually run long
Most delays come from work that happens before the first table is created. On either format, the storage layout, the catalog and the engine configuration have to be settled first, and each one touches the others. For Iceberg, the choice of catalog (Hive Metastore, AWS Glue, JDBC, REST, Nessie or Snowflake, selected through iceberg.catalog.type in Trino) decides how tables are registered, how they are backed up and who must be on call when the catalog is unavailable. The catalog is a service you run, so its high availability design belongs in the scope from day one. For Delta Lake, the table location and the transaction log live in object storage with the data, so the work centers on storage permissions, log retention and the engine connectors you configure for Spark, Trino or Flink. Ask each vendor or your own platform team to document the catalog or log location, the failover path and the owner of each setting before work is scoped.
Trino access control and fault-tolerant execution are where estimates most often move. Trino documents file-based access control, Apache Ranger and Open Policy Agent, and the choice has to be made before users are onboarded, because rewriting policies after go-live is expensive. Confirm which model your security team will enforce and whether it can express the table and column rules you already have. Fault-tolerant execution is off by default and needs a QUERY or TASK retry policy. The TASK policy needs an exchange manager spooling to S3, Azure Blob Storage, Google Cloud Storage or HDFS, so the bucket, its encryption and its lifecycle rules are part of the design, not an afterthought. Common delays include undocumented ingestion jobs that write to tables nobody has inventoried, and mixed write engines, where Spark, Flink and Trino each write to the same table with different assumptions about commits and maintenance. Inventory every writer before migration begins.
Fixed-scope delivery works best when the written scope names the writers, the policies and the migration path. DeployOpen plans, implements, integrates and documents self-hosted platforms inside the client's own infrastructure, and most engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts. For a lakehouse, a useful scope lists the catalogs and storage locations in use, every engine and ingestion job that writes, the access model to be enforced, the exchange storage for any fault-tolerant execution, the data migration method and the acceptance tests. Ask for the list of assumptions that would change the timeline, and for the change process when a discovered job or policy falls outside that list.
Questions buyers ask before choosing or hiring help for a lakehouse format
Can we switch table formats later if we pick the wrong one?
Yes, but the cost of switching grows with the number of tables, the amount of history you keep and the number of jobs that write to them. Both formats commonly store data in Parquet files, so the data files may be reusable, while the metadata layer, the catalog and the writers usually need to be converted or rebuilt. Treat the choice as a multi-year commitment for the catalog and the write path. Before you commit, ask your engineers to list every engine, job and BI tool that touches the tables, and confirm which of those each format supports in the versions you run. Iceberg's metadata and Delta's transaction log are different structures, so any conversion needs a tested plan and a rollback path.
How long does a migration between table formats take?
No supplied figure gives a duration, so treat any number you hear as unverified until you measure it in your own environment. The main drivers are total data volume, the number of tables, how much snapshot or version history must survive the move, and how many writers must be paused or cut over. Conversion is only part of the work. Catalog changes, query tests on each engine, access policies and BI connections all add effort. Ask any implementation partner for a written migration plan that lists the tables in scope, the cutover order, the validation checks and the rollback steps, and ask which assumptions about downtime and data volume the plan uses. A quote should follow from that written scope.
Can Trino run both Iceberg and Delta Lake tables in one cluster?
Yes. Trino lists both an Iceberg connector and a Delta Lake connector, and it queries data in place through connectors without loading that data into its own storage. The Iceberg connector works with Hive Metastore, AWS Glue, JDBC, REST, Nessie and Snowflake catalogs, selected with iceberg.catalog.type, and it supports Iceberg format versions 1 and 2, with version 3 marked experimental. The Delta Lake README lists a Trino connector that reads from and writes to Delta Lake. Confirm the specific Delta features your tables use against the connector documentation for the Trino release you deploy, since Trino 484 was published on October 15, 2026, and your version may differ. Plan separate object storage and a table catalog for each format, and test joins across both before you depend on them.
Does UniForm remove the need to choose a table format?
No. Delta.io states that UniForm, Delta Universal Format, lets Iceberg and Hudi clients read Delta tables, which can reduce how many copies of the same data you keep for different readers. It does not remove the choice. Writers still produce one primary format, the metadata must stay in sync, and you still need to confirm which readers, catalogs and features each engine supports in your version. Check how each engine handles the operations your tables depend on, such as deletes, schema changes and time travel, and test those paths in a staging copy. Ask for the exact read behavior of each client in writing, and name the team that owns the sync process and its monitoring.
What skills does our team need to run either format?
Your team needs working knowledge of the compute engines you choose, usually Spark or Trino, plus object storage, a table catalog and the day-to-day operations of the format itself. Iceberg adds a catalog service that you must run, secure, upgrade and back up, and the catalog you pick determines much of that work. Delta Lake work often centers on Spark and the transaction log, while Trino-first teams should test Delta connector features against their own workloads. Skills to check include table maintenance such as compaction and old-version cleanup, access control, and upgrade testing. Trino 484 requires a 64-bit Java 25 runtime, minimum 25.0.1, so confirm that your platform team can maintain that runtime alongside the rest of the stack.
Can DeployOpen implement an Iceberg or Delta Lake lakehouse for us?
DeployOpen plans, implements, customizes, integrates, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside the client's own infrastructure, including cloud accounts, data centers and air-gapped networks. A lakehouse build in that environment falls within this scope. Most engagements are fixed-scope, so the scope, deliverables and timelines are agreed in writing before work starts, and ongoing support, upgrades and continuous testing are available as retainers. DeployOpen does not publish a price list, and a quote follows from the written scope. Ask that the scope name the engines, catalog, storage layer, access controls, backup approach and compliance evidence you need. DeployOpen prepares systems and evidence for compliance assessments but does not issue audit reports or certifications.
What drives the total cost of a lakehouse format decision?
The cost has four main parts: internal staff time, compute and storage, the operation of the catalog and engines, and any outside services. Both Apache Iceberg and Delta Lake are open-source projects under the Apache License 2.0, so the format code carries no license fee, but you still pay for infrastructure, people and any implementation partner. One-time costs include design, migration, testing and training. Recurring costs include storage, compute, catalog hosting, upgrades and any retainer. Costs rise with the number of engines, data volume, write frequency, the amount of deletes and upserts, and the compliance evidence you must produce. When you request a quote, ask for one-time and recurring costs listed separately, with the assumptions, engines and versions named, and the staff effort each party is expected to contribute.
Which catalog should we choose, and does it change the answer?
The catalog matters most for Iceberg, because engines use it to find and track table metadata. Trino's Iceberg connector supports Hive Metastore, AWS Glue, JDBC, REST, Nessie and Snowflake catalogs, and the right choice depends on which engines you run and where your metadata must live. Delta tables keep their transaction log in storage, but engines still need a way to discover those tables, so you should confirm how your chosen engines register and find Delta tables. For both formats, ask who operates the catalog, how it is backed up and upgraded, and whether it sits inside your compliance boundary. Check the Trino Iceberg connector documentation for the catalog options supported by your Trino release before you finalize the design.
How DeployOpen helps choose, implement or migrate a lakehouse format
DeployOpen plans, implements, integrates, hardens, documents and supports self-hosted open-source platforms inside the client's own cloud accounts, data centers or air-gapped networks. For Apache Iceberg vs Delta Lake, that means starting from your engines, catalogs and governance requirements, then building and handing over the table format decision in your environment.
How we scope
- Inventory the engines that must read the same tables, such as Spark, Trino and Flink, and their versions.
- Confirm the catalog choice, whether Hive Metastore, AWS Glue, a REST catalog, Nessie or Snowflake, before any build starts.
- Agree the written scope, deliverables and timeline in writing before work begins, as most engagements are fixed-scope.
How we build
- Stand up the chosen table format, catalog and object storage in your accounts or data centers.
- Configure Trino or Spark connectors, authentication and access control to match your existing identity setup.
- Test time travel, schema evolution, deletes and merges against representative tables before anything reaches production.
How we hand over
- Document the format, catalog and engine configuration so your own platform team can operate it.
- Prepare the evidence your compliance assessors will ask for, without issuing any audit report or certification ourselves.
- Walk your team through runbooks for upgrades, rollbacks and table maintenance in your environment.
How we support
- Ongoing support, upgrades and continuous testing are available as a retainer after handover.
- Plan format and engine version upgrades with your team, checking compatibility before each change is applied.
- Confirm with the vendors and projects involved which capabilities your chosen versions support before committing.

