Data Lakehouse vs Data Warehouse for Multi-Cloud Data: Which Architecture Holds Up?
A research-based comparison of lakehouse and warehouse architectures in multi-cloud estates: workload fit, egress costs, open table formats, lock-in, residency, and AI workloads, with an acceptance checklist for evaluating either choice.
Most enterprises no longer run analytics in one cloud. Acquisitions arrive with their own platforms, regulators demand that certain datasets stay in certain jurisdictions, and procurement teams increasingly treat single-provider dependency as a risk to be managed rather than a convenience to be enjoyed. The architecture decision that looked settled in a single-cloud estate gets re-tested the moment a second cloud enters the picture.
The tension is real. A data warehouse concentrates mature SQL optimization, access control, and residency guarantees inside a managed service, but it assumes the data lives where the warehouse lives. A lakehouse puts data in open formats on object storage that any engine can read, but it hands the catalog, the policy layer, and the table maintenance back to your team. Neither property is free, and the costs land in different budget lines.
This comparison works through the dimensions that actually decide the question: workload mix, data movement and egress, cross-cloud query paths, lock-in, governance and residency, and AI and streaming workloads. It draws on published vendor pricing pages, the Apache Iceberg and Delta Lake specifications, and the CIDR 2021 lakehouse paper. It is a research-based comparison, not a hands-on benchmark; where a number comes from a vendor's list price or a paper's own test, it is labeled as such.
Quick comparison: how each architecture behaves under multi-cloud pressure
The table below summarizes the reasoning developed in the sections that follow. Treat it as a map, not a verdict — each row compresses a trade-off that depends on your specific data volumes, regions, and team capacity.
Dimension | Data warehouse | Lakehouse |
|---|---|---|
Storage model | Proprietary format managed by the provider; schema-on-write | Open formats (Parquet, ORC) on object storage, with a transactional metadata layer such as Iceberg or Delta Lake |
Cross-cloud query path | Query runs where the warehouse runs; data outside that cloud must be loaded or federated | Any compatible engine reads the files directly; the catalog and credentials are the coordination point |
Egress exposure | Cross-cloud reads become egress events billed by the storage provider; Snowflake documents egress costs when an Iceberg table's external volume sits in a different region | Egress follows where compute runs relative to where files sit, not whether a second engine can read them |
Lock-in profile | Strong on compute and SQL dialect; data extraction is possible but costly at scale | Weaker on data (files are readable elsewhere); residual dependency on catalog implementation, engine feature coverage, and maintenance operations |
Workload fit | Stable structured BI and reporting; mature SQL optimization | Mixed structured, semi-structured, and unstructured data; ML feature work; streaming; batch and interactive on one copy |
Governance ownership | Largely the provider's managed surface: access control, lineage, residency controls | Assembled and owned by your team: catalog, policy engine, audit, and table maintenance |
The rows that most often flip a decision are egress exposure and governance ownership. The first is a recurring bill; the second is a recurring operational commitment.
Evaluation criteria: what actually decides this
Before comparing architectures, define what the comparison has to survive. The useful question is not which architecture is newer, but which one holds up under four pressures that multi-cloud estates generate simultaneously.
Mixed workload types. A platform that serves only BI reports can be optimized narrowly. One that also serves data science, streaming ingestion, and AI feature pipelines has to keep one copy of data readable by several engines. The workload mix determines whether a warehouse's closed-world optimization is an advantage or a constraint.
Data reachable from more than one cloud. If a dataset must be queried from two clouds, either it is copied, it is federated, or it is stored somewhere both clouds can read cheaply. Each option has a different cost curve and a different failure mode.
Regulatory residency constraints. Residency is not a performance property; it is a legal one. The EDPB's guidelines on the interplay between Article 3 and Chapter V set out three cumulative criteria for when a processing operation counts as a transfer of personal data to a third country, which is the analysis that determines whether a given cross-border data path is permissible at all. Architecture choices that move data across regions have to be checked against that analysis, not just against latency.
A credible exit path. Lock-in is measured by what it costs to leave, in money and in engineering time. An architecture that can be exited in a quarter is a different risk profile from one that cannot be exited at all.
The evidence has limits worth stating up front. Vendor pricing pages describe list prices, not negotiated rates, and list prices change. The Iceberg and Delta Lake specifications describe what the formats permit, not how completely any particular vendor implements them. The CIDR 2021 paper is written by Databricks researchers and evaluates a Databricks system; its performance results are the authors' own TPC-DS comparison, not an independent benchmark.
Workload mix: is a data warehouse still sufficient?
For a large class of enterprises, the honest answer is yes. A warehouse remains a good fit when the workload is stable BI and reporting over structured data, the schema is well understood, and the team values a managed optimization layer it does not have to tune. Schema-on-write, mature SQL optimization, and provider-managed access control are genuine advantages in that setting, and nothing about multi-cloud erases them — it only adds a constraint on where the data can sit.
The strain appears when the workload mix widens. The CIDR 2021 lakehouse paper, written by Armbrust, Ghodsi, Xin, and Zaharia, argues that the two-tier lake-plus-warehouse architecture dominant in large enterprises creates three recurring problems: data quality and reliability, because the lake and warehouse can carry different schemas and semantics and every additional ETL job adds a failure point; data staleness, because a separate staging area and periodic loads delay freshness; and cost, because the same data is maintained in two places. The paper also notes that SQL warehouses do not easily support the unstructured data — images, sensor data, documents — that many industries now collect, and that they serve machine learning workloads poorly compared with direct object-store access.
That is the paper's argument, and it should be read as one. Its performance claim — that a lakehouse system using Parquet is competitive with popular cloud data warehouses on TPC-DS — comes from the authors' own comparison of the Databricks Delta Engine against those warehouses. It is evidence that the approach can work, not an independent ranking of products.
A decision rule follows from the workload characteristics rather than from the paper's conclusion. If more than a small fraction of your analytical demand is structured BI over stable schemas, and the data science and streaming workloads are marginal, a warehouse is sufficient and the operational simplicity is worth real money. If data science, streaming, or semi-structured data are on the critical path — not aspirational, but already blocking delivery — the two-tier architecture is where your engineering time will go, and the lakehouse pattern becomes the lower-friction option.
Data movement and egress: what multi-cloud actually costs
Cross-cloud data movement has a published price, and it is large enough to shape architecture. The figures below are list prices from each provider's public pricing page, in the regions and tiers stated. Negotiated rates differ, and so do the tiers that apply at your volume.
List prices for internet data transfer out, first paid tier, from North America/Europe. Google Cloud Premium Tier: $0.12/GiB for 1–1,024 GiB per month per account (first 1 GiB free). Azure: $0.087/GB after the first 100 GB/month free. AWS publishes a 100 GB/month free allowance aggregated across services and regions, but its per-GB tier rates are not stated on the primary pricing page cited here, so no AWS bar is shown. These are list prices for internet egress, not negotiated rates, and not cross-cloud private connectivity or intra-cloud transfer.
Google Cloud publishes tiered data transfer out rates under its Premium Tier. To North America, the first gibibyte per month per account is free, the next tier up to 1,024 GiB is $0.12 per GiB, 1,024 to 10,240 GiB is $0.11 per GiB, and above 10,240 GiB is $0.08 per GiB. To Europe the structure is the same, with the top tier at $0.085 per GiB. Destinations such as Australia, Indonesia, Korea, South America, and Saudi Arabia start at $0.19 per GiB with no free first gigabyte. Data transfer in is free.
Microsoft Azure publishes a bandwidth table by source continent. From North America or Europe to any destination, the first 100 GB per month is free, the next 10 TB is $0.087 per GB, the next 40 TB is $0.083 per GB, the next 100 TB is $0.07 per GB, and the next 350 TB is $0.05 per GB. From Asia (excluding China), Australia, and MEA the first tier is $0.12 per GB.
AWS aggregates data transfer out to the internet across a long list of services — including EC2, S3, RDS, Redshift, SageMaker, DynamoDB, and CloudWatch Logs — for the purpose of rate tiers, and gives customers 100 GB per month free, aggregated across all AWS services and regions except China and GovCloud. AWS also states that eligible customers receive free data transfer out when they move all of their data off AWS or off a particular AWS service.
The lock-in argument that egress fees make leaving a provider expensive is made explicitly by DigitalOcean in its analysis of AWS egress costs, which notes that high data transfer fees can cause vendor lock-in by making it expensive to move data off AWS, including for a multi-cloud strategy. That is a competitor's characterization and should be read as such; the pricing tables above are the primary evidence, and they support the narrower point that cross-cloud reads carry a real, published cost.
The architectural consequence is what matters for the warehouse-versus-lakehouse decision. A warehouse that stores data in its own cloud turns a cross-cloud read into an egress event billed by the storage provider. A lakehouse on object storage does not eliminate egress — it relocates the question. The bytes still have to travel from wherever the files sit to wherever the compute runs. What changes is that you can choose where to put the compute, and you can choose to run the query in the region where the data already is. The egress question becomes a placement decision rather than a fixed property of the architecture.
Querying across clouds without copying: what the open table formats actually enable
The Iceberg REST catalog protocol is often described as the thing that makes cross-engine access work, so it is worth being precise about its scope. The REST catalog specification defines a common API, expressed as an OpenAPI spec, for interacting with any Iceberg catalog. The project's stated motivations are language and engine compatibility through a single client implementation, improved reliability through change-based commits with server-side deconfliction and retries, simplified metadata management because root metadata is written by the catalog service, advanced features such as lazy snapshot loading and multi-table commits, and security through credential vending or remote signing for table sharing.
Those are catalog operations. The protocol standardizes how an engine discovers tables, negotiates commits, and obtains credentials. It does not standardize where the data files live, and it does not move them. A query engine using a REST catalog still reads data files from the object store where they sit. The distinction is worth stating plainly: the protocol lets you query without copying metadata and credentials, not without moving bytes.
Vendor documentation makes the byte movement concrete. Snowflake's Iceberg table documentation states that for both externally cataloged tables and tables where Snowflake is the catalog, if the Snowflake account and the external volume are in different regions, the external cloud storage account incurs egress costs when the table is queried. Snowflake's Cross-Cloud Auto-Fulfillment documentation describes a different mechanism: it reads data directly from the external volume and replicates all data as a Snowflake-managed Iceberg table within the target regions, with providers charged for the consumption of the Snowflake-managed data, including egress, storage, and compute. That is replication to avoid repeated cross-region reads, not the elimination of the copy.
For a multi-cloud estate, the practical reading is this. Open table formats and the REST catalog make it possible for several engines to address the same tables without a proprietary export step. They do not make cross-cloud reads free, and they do not remove the need to decide where compute runs relative to where data sits. The architecture that holds up is the one where that placement decision is explicit and measured, not assumed away.
Reducing vendor lock-in: what open formats buy and what they don't
Open table formats reduce lock-in in a specific and real way: the data files are readable by any engine that implements the format, so the data itself is not trapped inside a proprietary store. The Delta Lake documentation describes what the format provides — ACID transactions with serializable isolation on Spark, scalable metadata handling for petabyte-scale tables, streaming and batch unification so that a table is both a batch table and a streaming source and sink, schema enforcement, time travel for rollbacks and reproducible machine learning experiments, upserts and deletes, and a connector ecosystem that includes Spark, Flink, Hive, Trino, and Athena. The Iceberg table specification defines a versioned metadata model with snapshots, manifest lists, and manifest files, and its format versions add capabilities such as delete files in version 2 that allow row-level deletes without rewriting data files.
What remains after the format is open falls into three categories.
Catalog implementation. The tables are readable, but something has to track which files constitute the current table state and arbitrate concurrent commits. That catalog is a dependency. The REST protocol reduces the cost of switching catalogs by standardizing the client interface, but the catalog service itself is still a component you choose, operate, and potentially migrate.
Compute engine feature coverage. A format permits a feature; an engine may not implement it. The Iceberg spec is explicit that format versions are incremented when new features break forward compatibility, and that tables may continue to be written with an older version to preserve compatibility with engines that have not implemented newer features. In practice, the feature set you can use is the intersection of what the format allows and what every engine in your stack supports.
Table maintenance. This is the dependency teams most often underestimate. Iceberg's maintenance documentation treats snapshot expiration and manifest rewriting as routine operations: snapshots accumulate until expired, and regularly expiring them is recommended to delete unneeded data files and keep table metadata small. Compaction rewrites data files and can remove dangling delete files. These are recurring jobs that someone has to own, schedule, and monitor.
The regulatory backdrop is moving in the same direction as the technical one, at least in Europe. The EU Data Act's switching-charge provisions, as summarized by Springlex, require providers of data processing services to eliminate switching charges entirely from 12 January 2027, with charges between 11 January 2024 and that date capped at costs directly linked to the switching process. Springlex describes its summary as a documentation tool with no legal effect and states that the authentic version is the one published in the Official Journal. For planning purposes, the direction is clear — switching costs are being pushed down — but the specific obligations should be confirmed against the official text.
Governance, residency, and operational burden
Governance is where the two architectures diverge most sharply in day-to-day ownership, and it is the dimension most often decided by accident rather than by design.
In a warehouse, access control, lineage, and residency controls are largely the provider's managed surface. You configure users, roles, and policies inside a service that also enforces them. The provider's regional footprint determines where data can be stored, and the provider's audit logs record access. The trade-off is that the controls are the provider's controls, expressed in the provider's model, and they apply to data inside the warehouse.
In a lakehouse, the storage layer is open, which means the catalog, the policy engine, and the audit trail have to be assembled and owned by your team. The Iceberg REST protocol provides the mechanism for secure table sharing through credential vending or remote signing — the catalog can check whether a client is allowed to access a table before granting credentials to read the underlying files, and can log the access. That is a building block, not a complete governance program. Someone has to define the policies, integrate the catalog with your identity provider, retain the audit records, and verify that every engine in the stack honors the controls.
Interoperability frictions are documented by vendors and are worth reading as implementation-specific constraints rather than as properties of the format. Databricks' documentation for external Iceberg access states that because the Iceberg specification does not allow duplicate data files in a single table snapshot, Unity Catalog blocks external engines from committing duplicate data files when detected. The same documentation notes that when an external Iceberg client runs a row-level change on a managed Iceberg v3 table, the client must use copy-on-write mode or record deleted rows as Iceberg v3 deletion vectors, and that equality delete files are rejected. Microsoft's Azure Databricks version of the same page adds that Snowflake does not support Entra authentication for catalog integrations that use private networking to connect to Azure Databricks, and that the connection must use public networking when authenticating with an Entra service principal. These are the kinds of constraints a buyer must verify against their own stack; they do not describe the format, they describe one vendor's implementation of it.
Residency deserves separate treatment because it is a legal question before it is a technical one. The EDPB's Guidelines 05/2021 set out three cumulative criteria for when a processing operation qualifies as a transfer of personal data to a third country: the exporter is subject to the GDPR for the processing, the exporter discloses or makes the data available to another controller or processor, and the importer is in a third country or an international organization. The guidelines also note that processing outside the EU can carry increased risks requiring safeguards even where a flow does not constitute a transfer under Chapter V. A lakehouse that lets any engine in any region read a table is a governance capability and a residency risk at the same time; the architecture has to make the region of every dataset visible and enforceable, not merely possible.
AI/ML and streaming: how these workloads shift the decision
Machine learning and streaming workloads change the weighting of the criteria rather than introducing new ones. They raise the value of direct file access, lower the tolerance for staleness, and make the cost of moving data between systems more visible.
The CIDR 2021 paper characterizes the lakehouse pattern by three properties: open direct-access data formats such as Parquet and ORC, first-class support for machine learning and data science, and competitive performance. The paper's argument for the second property is that ML libraries can already read data lake file formats, so the simplest integration is to query the metadata layer to determine which files are currently part of a table and pass those to the library. It also notes that data warehouses are a poor fit for large-scale ML because streaming data out of them is inefficient compared with direct object-store access. That is the authors' characterization of the pattern they are advocating, and it aligns with the practical observation that feature engineering pipelines want file-level access, not a SQL endpoint.
Streaming changes the freshness calculus. The Delta Lake documentation states that a Delta table is a batch table as well as a streaming source and sink, so streaming ingest, batch backfill, and interactive queries operate on the same table. That property matters in a multi-cloud estate because it means one copy of the data can serve both the real-time path and the historical path, rather than maintaining a streaming store and a warehouse copy that drift apart.
Vendor-reported capabilities should enter this section only as claims to validate. Singdata, for example, publishes claims about a unified engine that handles batch, streaming, and interactive compute on one architecture, with incremental processing intended to keep data fresh without reprocessing everything. Those are vendor-reported claims about a specific product, not established performance facts, and a buyer should test them against their own workload — the same standard that applies to any vendor's benchmark. The relevant question is not whether a vendor's published number is impressive but whether the architecture lets you measure freshness, cost, and query latency on your own data before you commit.
Who should choose which
The self-selection below is keyed to the criteria established above, not to product preference. Most organizations will recognize themselves in one profile and partially in another.
A warehouse remains the lower-risk choice when: the analytical demand is predominantly structured BI and reporting over stable schemas; the data footprint is effectively single-cloud, so cross-cloud reads are rare exceptions rather than daily operations; the platform team is small and would rather consume a managed optimization and governance layer than operate one; and the exit path, while not free, is not a live requirement. In this profile, the warehouse's closed-world design is an advantage, and a lakehouse would add catalog and maintenance work without a corresponding benefit.
A lakehouse is the better fit when: the data mix includes semi-structured or unstructured data that a SQL warehouse handles poorly; machine learning is on the critical path rather than a side project; there is a genuine multi-cloud requirement, whether from acquisition, regulation, or a deliberate decision to avoid single-provider dependency; or there is a credible exit requirement that the organization intends to exercise. In this profile, open formats and direct file access reduce the number of copies and the number of systems that have to be kept consistent.
The hybrid case is common and often correct: a warehouse queries open-format tables in object storage, keeping the warehouse's SQL and governance surface for BI while the data itself lives in an open format that other engines can read. Google Cloud, for example, documents that BigQuery can directly query Iceberg tables in Cloud Storage without data movement. The hybrid reduces lock-in on data while retaining the warehouse's strengths on compute — at the cost of the egress and cross-region considerations described earlier, which have to be measured rather than assumed.
When the answer is "it depends," it depends on three things: the volume of data that must cross cloud boundaries and how often, the residency obligations attached to specific datasets, and the team's capacity to own catalog operations and table maintenance. Those three variables, more than any product comparison, determine which profile fits.
Proving the choice: an acceptance checklist
The checklist below is a proposed evaluation framework, not an observed result or a vendor's methodology. Each item is testable before commitment and ties back to a criterion discussed earlier.
Measure egress for your actual query patterns. Take the cross-cloud queries you run today, or the ones you expect to run, and calculate the bytes transferred per month against the published rates for your source and destination regions. Compare the result with the negotiated rates your provider has offered. If the number is material, the placement decision described earlier is the lever.
Test a cross-engine read and write path against the chosen catalog. Have a second engine — not the one that created the table — read the table and, if your workload requires it, write to it. Confirm which format features the second engine supports, and check the vendor's documented limitations for external clients before assuming parity.
Document a residency map for every dataset. For each dataset, record the region where it is stored, the regions where it is queried, and the legal basis for any cross-border access. Use the EDPB's three-criteria analysis as the test for whether a given path is a transfer.
Run a lock-in exit test. Ask whether a second engine can read the tables today, without an export step. If the answer is no, identify what would have to change and estimate the engineering time. That estimate is your lock-in cost.
Assign maintenance ownership. Name the team responsible for snapshot expiration, manifest rewriting, compaction, and orphan file deletion, and put those jobs on a schedule with monitoring. Unowned maintenance is the most common way a lakehouse degrades quietly.
Define a pilot period with success criteria. Set a fixed window, the workloads in scope, and the thresholds for freshness, query latency, and cost that would justify proceeding. Measure against your own baseline rather than a vendor's published benchmark.
FAQ
Can a data warehouse query lakehouse tables directly? In some cases, yes. Google Cloud documents that BigQuery can directly query Iceberg tables in Cloud Storage without data movement. Snowflake documents support for Iceberg tables using an external catalog or Snowflake as the catalog, with the caveat that if the account and the external volume are in different regions, the external storage account incurs egress costs when the table is queried. Support varies by provider and by table type, so confirm the specific configuration with your vendor.
Can Iceberg and Delta Lake tables coexist in one estate? They are separate formats with separate metadata models, and both are open. The practical constraint is not coexistence but engine support: each engine in your stack must be able to read the format you choose, and feature coverage differs. Iceberg's documentation includes a Delta Lake migration module, which indicates migration paths exist, but the migration itself is a project with its own testing requirements.
What does the REST catalog standardize, and what does it not? It standardizes catalog interaction: a common API for catalog operations, a single client implementation that works across languages and engines, server-side commit deconfliction, and secure table sharing through credential vending or remote signing. It does not standardize data locality. A query engine still reads data files from wherever they sit, and cross-region reads still incur egress on the storage account.
How do egress costs compare across the three major providers at list price? At list price, Google Cloud charges $0.12 per GiB to North America and Europe in the first paid tier, with the first gibibyte free per month. Azure charges $0.087 per GB from North America and Europe after the first 100 GB per month free. AWS gives 100 GB per month free, aggregated across services and regions, and applies rate tiers based on aggregate usage; its per-GB rates are published on its pricing pages and vary by service and destination. These are list prices in stated regions and tiers, not negotiated rates, and they change — confirm current rates before modeling.
Does the EU switching-charge timeline change near-term planning? It changes the direction of travel, not the immediate decision. As summarized by Springlex, charges between 11 January 2024 and 12 January 2027 are capped at costs directly linked to the switching process, and must be eliminated entirely from 12 January 2027. Springlex states that its summary has no legal effect and that the Official Journal text is authoritative, so any planning that depends on the specific obligations should be checked against the official text and, where relevant, legal advice.