40 min read

Inside the Data Center: How a Lakehouse Serves AI and Real-Time Analytics

A conceptual guide to lakehouse architecture in the data center: how open table formats, layered storage and governance let one governed copy of data serve AI training, inference and real-time analytics — plus criteria for vetting vendor claims.

Inside the Data Center: How a Lakehouse Serves AI and Real-Time Analytics

Introduction

Most enterprises now run two data platforms for the same business. One holds cheap, flexible files for data science and machine learning; the other holds curated tables for dashboards and reporting. Both are fed from the same operational systems, and within a year they disagree. The AI team scores a customer one way, the BI team reports that customer another way, and nobody can say which number is right without tracing two pipelines back to the source.

A lakehouse is the architectural answer to that problem: one governed copy of the data, stored in open formats, that both AI workloads and analytical queries can read. This article is a conceptual explainer, not a product review. By the end, you should be able to name the layers of a lakehouse, separate the several meanings of "real-time," and ask a vendor the questions that distinguish a genuine lakehouse from a data lake or warehouse with a new label.

The basis is vendor and open-format documentation, cited inline. Where a vendor publishes performance or cost figures, they are treated as claims to validate in your own environment rather than established fact.

Why Two Copies of Data Became a Problem

The split is not an accident of tooling; it follows from two different jobs. A data lake stores raw files in object storage. It is inexpensive at volume and accepts almost any shape of data, which is why data scientists and machine-learning engineers use it for exploration and model training. A data warehouse stores tables that have been cleaned, modeled and governed. It is optimized for the structured, repeated queries that business intelligence depends on.

When both platforms are fed from the same sources, the cost appears in three places. Pipelines duplicate: the same extraction and transformation logic is written twice and maintained twice. Definitions diverge: a "active customer" means one thing in the lake's feature pipeline and another in the warehouse's reporting model. And reconciliation becomes a permanent job, because the two copies drift as source systems change and each team fixes its own side.

The practical consequence is that the organization cannot fully trust either number. The lakehouse answers a narrow but important question: can one governed copy of the data serve both the AI workload and the analytical workload, so that the definition, the history and the access controls are shared?

What a Lakehouse Actually Is

A lakehouse is open file storage plus a table format that adds warehouse-style guarantees on top of it. The storage layer is ordinary object storage. The table format is what makes that storage behave like a managed table: transactions, schema enforcement, time travel and consistent reads.

The enabling layer is the open table format. Apache Iceberg describes itself as "an open table format for huge analytic datasets" that adds tables to compute engines including Spark, Trino, PrestoDB, Flink, Hive and Impala, using a format that works like a SQL table (Iceberg documentation). Delta Lake provides ACID transactions, scalable metadata handling, and unified streaming and batch processing on top of existing data lakes such as S3, ADLS, GCS and HDFS, with schema enforcement and time travel (Delta Lake documentation).

The "so what" is where the guarantees live. In a traditional warehouse, transactional behavior and governance are properties of the proprietary system. In a lakehouse, they are properties of the table format and its metadata, which is why several different engines can read the same data without copying it. That is the architectural shift a general B2B reader needs to hold onto: the table format, not the vendor's compute product, is what makes one copy shareable.

The Layers of a Lakehouse in the Data Center

Reading the stack from the source systems outward gives a usable mental map. Each layer has a job, and most lakehouse failures trace to one layer being skipped or overloaded.

Ingestion. Data arrives as batch extracts, as continuous streams, or as change data capture (CDC) that carries inserts, updates and deletes from operational databases. CDC matters because it keeps the lakehouse synchronized with source systems without full reloads; Google Cloud's documentation describes CDC ingestion for Iceberg managed tables as capturing incremental changes so the lakehouse reflects the current state of operational data (Google Cloud CDC documentation).

Open storage. Files sit in object storage. This layer is cheap and durable, and it is deliberately decoupled from compute so that different engines can query the same open tables (Google Cloud lakehouse concepts).

The table and metadata layer. This is the table format described above. It tracks which files make up a table at a given version, enforces schema, and records the history that time travel reads.

Compute engines. Separate engines handle batch SQL, streaming, and machine-learning workloads against the same tables. Decoupling means an engine can be added or replaced without moving the data.

Governance and catalog. Access control, lineage and discovery apply across engines rather than inside a single product. This layer is what makes "one governed copy" more than a slogan.

Serving. BI tools, applications, APIs and AI agents read from the curated tables. Many teams organize the quality tiers using the medallion pattern — bronze (raw), silver (validated), gold (enriched) — which Databricks documents as a recommended best practice rather than a requirement (medallion architecture).

"Real-Time" Means Four Different Things

This is where most conversations go wrong. "Real-time" is used for at least four different latencies, and a system can be excellent at one while being slow at another.

Ingestion latency is the delay between an event occurring and its arrival in the platform. Processing latency is the time to transform and validate it. Query latency is the time for a dashboard or API to return an answer once asked. Decision latency is the time from event to a human or automated action — which includes all of the above plus whatever approval or application step follows.

Databricks' overview of real-time analytics offers illustrative bands: real-time at milliseconds to under a second, suited to fraud detection, algorithmic trading and ad bidding; near real-time at seconds to about a minute, suited to live dashboards, personalization and IoT monitoring; and batch at minutes or hours to daily, suited to historical reporting, forecasting and financial close (Databricks, real-time analytics). These are typical ranges for each approach, not guarantees for any product.

The same source adds a dimension that freshness alone misses: concurrency. Internal BI tools may serve dozens or hundreds of concurrent users, while customer-facing dashboards, embedded analytics, APIs and AI agents often generate thousands of simultaneous requests. A platform that returns one query in 200 milliseconds can still fail under that load.

The practical instruction follows: before evaluating any architecture, ask which of the four latencies the business decision actually depends on. A fraud check needs sub-second ingestion and processing. A daily financial close does not, and paying for streaming infrastructure to serve it is waste.

One Copy for AI Training, AI Inference and Analytics

AI makes the single-copy question sharper because AI workloads read the same data at different points in time. Training reads history: months or years of examples. Inference and AI agents read current state: what is true about this customer, order or device right now. Dashboards read aggregates over both. If these come from different copies, the model learns one version of reality and is scored against another.

The mechanism that prevents this is established practice in feature management. Microsoft's documentation for its managed feature store describes using the same feature pipeline for both training data generation and inference to provide online/offline consistency and avoid training/serving skew, and notes that feature retrieval supports point-in-time temporal joins to avoid data leakage (Azure Managed Feature Store). Point-in-time correctness means that when you reconstruct what the model would have known at a past moment, you do not accidentally include data that arrived later.

Time travel in the table format supports the reproducibility side. Delta Lake documents time travel as enabling rollbacks, full historical audit trails and reproducible machine learning experiments (Delta Lake documentation). A shared table format therefore makes consistency achievable: training and inference can read the same governed tables, and a past state can be reconstructed exactly.

The scope matters, though. A shared table format does not by itself guarantee consistency. Pipeline design, feature definitions and governance still decide whether the training and serving paths actually agree. The format removes the architectural obstacle; it does not remove the engineering work.

Telling a Real Lakehouse from a Relabeled Lake or Warehouse

Vendors now apply the lakehouse label broadly, so the reader needs criteria rather than a product ranking. A genuine lakehouse should demonstrate the following, and each item can be checked in a proof of concept.

Open table formats readable by multiple engines. Iceberg's documentation states that it adds tables to engines including Spark, Trino, PrestoDB, Flink, Hive and Impala, and that it is developed as an open community standard with a published specification (Iceberg documentation). Ask which engines can read the same table without export.

Transactional guarantees. Iceberg documents serializable isolation, in which table changes are atomic and readers never see partial or uncommitted changes, with multiple concurrent writers using optimistic concurrency (Iceberg documentation). Ask what happens to a reader during a concurrent write.

Schema evolution without side effects. Iceberg documents schema evolution supporting add, drop, update and rename with no side effects, plus hidden partitioning that prevents user mistakes causing silently incorrect results or extremely slow queries (Iceberg documentation). Ask to see a column renamed on a live table with historical queries still working.

Time travel. Ask whether a query can be pinned to a specific table snapshot, and how long history is retained.

Governance across engines. Access control, masking and lineage should apply to the table regardless of which engine reads it, not only inside one product's SQL interface.

A warehouse with an export path to object storage, or a lake with a SQL endpoint bolted on, will usually fail one or more of these tests. The point is not to disqualify a vendor but to establish what you are actually buying.

Reading Vendor Performance and Cost Claims

Headline speed and cost figures are claims produced under the vendor's conditions. They are a reasonable starting point for a proof of concept and a poor basis for a procurement decision on their own.

When a vendor publishes a number, ask four questions. What workload was measured — a scan, a join, a concurrent dashboard load? What data volume and schema? What concurrency level? And what exactly was the baseline — which product, which version, which configuration? A figure without those four answers cannot be reproduced, and a figure that cannot be reproduced cannot be validated.

Singdata, for example, describes its lakehouse as reporting up to 4x faster performance than Snowflake, 10x faster than Spark, and a 50% reduction in total cost of operation. These are vendor-reported claims. They should be treated as hypotheses to test on your own data, at your own concurrency, against your own current baseline — not as established facts about your environment.

The same discipline applies to cost. Total cost of operation includes compute, storage, egress, engineering time and the operational overhead of running the platform. A lower compute bill that requires more engineers to operate is not necessarily a saving. Build the comparison around your measured workload and your fully loaded costs.

A Practical Starting Checklist

Use this list as acceptance criteria in a pilot rather than a summary of the article.

  • Name the latency the decision needs. Write down the required ingestion, processing, query and decision latency for the most important use case, and confirm that batch is not sufficient before paying for streaming.

  • Verify the table format is open and multi-engine. Confirm at least two independent engines can read the same table without export or copy.

  • Test schema evolution and time travel on real data. Rename a column, query history, and confirm that past snapshots are reproducible.

  • Confirm governance applies across engines. Check that access controls and masking follow the table, not the query tool.

  • Check that training and inference can share one feature pipeline with point-in-time correctness, and that the same definitions feed the dashboards.

  • Require any vendor performance or cost figure to be reproduced in the pilot, on your data, at your concurrency, against your baseline.

As AI agents and live dashboards raise both freshness and concurrency demands, the value of one governed copy grows rather than shrinks: every additional consumer makes a second copy more expensive to keep consistent.

FAQ

Is a lakehouse the same as a data lake? No. A data lake is open storage holding files. A lakehouse adds a table format on top of that storage, which supplies transactional guarantees, schema enforcement and time travel. The storage may be identical; the guarantees are not.

Does a lakehouse replace the data warehouse? It can absorb much of what a warehouse does, because the table format provides warehouse-style behavior over open storage. Whether it should replace your warehouse depends on your workloads, your existing governance model and the migration cost. Many organizations run both during a transition.

Do I need real-time processing for AI? Not necessarily. Model training is usually batch and reads history. Freshness matters most for inference and for AI agents that act on current state. Match the latency to the workload rather than to the label.

Is an open table format required? It is the mechanism that lets multiple engines share one governed copy. Without it, the guarantees tend to live inside a single proprietary system, and sharing data means copying it.

How do I compare vendor speed claims? Reproduce them. Ask for the workload, data volume, concurrency and baseline behind the figure, then run the same test on your own data in a pilot before committing.