Designing data architecture for production AI
Capable AI models routinely stall in production on stale, disconnected records. Here is the architectural blueprint for reducing processing delay, unifying departmental silos, and governing access at scale.

- Fix delay and silos together, as solving only one leaves AI acting on stale or incomplete data
- Tier freshness by decision speed, using change data capture (CDC) and precomputation only where latency costs money
- Blend integration patterns by consolidating core entities, federating the long tail, and publishing governed domain data products
- Make unified data trustworthy with deterministic entity resolution, a shared semantic layer, and row-level security for scoped agents
- Prove one workflow before scaling, reusing the same entities, pipelines, and policies for future AI use cases
The two data limitations blocking production AI
Fragmentation isn't just about where data lives, it's also about when it arrives. Two data problems stall AI in production, and they behave as one. The first is delay: by the time the system acts, the data it worked from is hours or days old. The second is separation: the facts it needs sit in departmental systems that were never designed to be read together. Fix one without the other and the gain is small. A fast pipeline into a fragmented store still returns an incomplete picture, and a unified store refreshed overnight still returns an old one.
This is the pattern behind many stalled agentic AI pilots. The model is capable, but the data foundation cannot support what it is asked to do. This piece sets out the architectural choices that address both problems, the trade-offs of each, and the order in which to make them. Access control runs through every design below, because unified data is only useful if the right people and agents can see the right parts of it.
Where processing delay comes from
Delay accumulates in four places, and most teams only look at one of them.
- Capture. How soon a change in a source system becomes available to read. A nightly extract sets a floor of up to 24 hours before anything downstream can react.
- Movement. The number of hops between source and consumer. Each hop runs on its own schedule, so three chained jobs on hourly schedules can add up to three hours in the worst case.
- Transformation. Heavy joins and aggregations, run either in long batch windows or at query time.
- Serving. Stores built for large analytical scans are slow at the repeated small lookups an AI agent makes.
Measure freshness as the gap between an event happening in the source and that event being queryable by the consumer, dataset by dataset. Most teams track whether a pipeline succeeded, not how old its output is, so a pipeline can run on schedule and still deliver data too old for the decision it feeds.
Four ways to reduce delay
Match freshness to the decision
Sort datasets into tiers by how quickly the decisions that use them are made: seconds, minutes, hourly, daily. Streaming everything is expensive and rarely necessary. Tiering puts the spend where delay costs money and leaves the rest on cheaper batch schedules.
Replace batch extracts with change data capture
Log-based capture reads a database's transaction log, which typically places little load on the source system and delivers changes in seconds to minutes. Pair it with streaming ingestion into the analytical store so the data is queryable on arrival.
Remove hops and precompute
Collapse chains of dependent jobs where you can. For joins and aggregates that agents or analysts request repeatedly, such as current stock by site or open orders by customer, compute them once at write time so every read does not repeat the work.
Serve by access pattern
Keep the analytical store for exploration and heavy queries, and put a low-latency store, such as a key-value, feature-serving, or vector layer, in front of the repeated lookups an agent makes. Populate both from the same pipeline so there is one source of truth and two ways to read it.
In practice: Tiering freshness for live decision-making
The cost of stale data shows up fastest when decisions happen in real time. Working with Beyond, Dyson faced this exact gap: its e-commerce trading team could analyse less than 0.5% of the organisation's data, and a single regional campaign during a peak trading event recorded a revenue deficit of €405,000. Integrating the critical trading data into one analytical layer on BigQuery and Looker, with views refreshing every 15 seconds, gave the team a live view across channels and markets so underperformance could be spotted and acted on while it still mattered. A 15-second refresh suits a team or a pricing agent, watching peak trading. A back-office process would not need it, which is the argument for tiering.
Unifying departmental data: three patterns
There are three broad ways to bring siloed data together, and each trades something away.
Consolidate
Copy shared data into one platform. This gives the best performance and consistency, and a single place to apply policy. The costs are migration effort and the need to settle who owns the data once it moves. It suits high-value shared entities such as customer, product and order, and anything with a tight freshness requirement.
Federate
Query data where it sits, across source systems. This is quick to start and avoids copying. The costs are that query speed depends on the slowest source, analytical load lands on operational systems, and an unavailable source means an unavailable answer. It suits the long tail of low-frequency or exploratory use.
Publish domain data products
Each department publishes governed datasets to the shared platform, with a named owner, a defined schema and quality checks. This scales ownership and keeps domain knowledge close to the data. It only works if standards are enforced, otherwise it recreates the silos in tidier form.
Most estates end up with a mix: consolidate the shared core, federate the long tail, and require domain teams to publish to common standards.
What makesS unified data usable
Bringing data into one place does not make it consistent. Three pieces of work decide whether an AI system can use it without hallucinating or leaking context.
Entity resolution
Customer, product, site and supplier need one identity across systems. Match deterministically on shared identifiers first, use fuzzier matching only for what remains, and log every match so it can be reviewed. Without deterministic key matching, an AI system will merge conflicting records silently and act on corrupted context.
A shared semantic layer
Define revenue, active customer and available stock once, in one governed place. Without that, two departments—and any agent querying their tables—will get two different answers to the same question, both correct by their own definition.
Policy at the data layer
Apply row-level and column-level security where the data lives, and run agents under scoped service identities with only the access their task needs. Consolidation should not widen access by default.
In practice: Proving the foundation before scaling
Unifying fragmented estates does not require a multi-year rewrite before delivering value. WPP had accumulated more than 300 siloed databases under a decentralised IT function, where slow, waterfall-style delivery made data projects costly and frequently unsuccessful. A pilot enterprise data platform on Google Cloud, delivered by Beyond in 14 weeks, brought those databases together for more than 1,000 users and data owners, with self-serve analytics and embedded ML. It was a pilot, not the end state - establishing the governed data foundation needed before scaling automated ML and agentic workflows across the estate. Google Cloud was subsequently confirmed as the group's primary cloud for data.
What to do first
- Pick one decision or workflow and write down how fresh its data needs to be.
- Measure the current freshness gap for each source it depends on.
- List the shared entities it needs and agree on common keys before moving any data.
- Choose consolidate, federate or publish for each source, using the patterns above.
- Set access policy before widening the audience, including for agents.
- Alert on freshness and quality, so degradation shows up before an agent acts on it.
The return appears in two places. The first is the decision itself: acting on current, complete data costs less than acting late, as the trading example shows. The second is reuse. The second AI use case on the same foundation costs less to stand up than the first, because the entities, policies and pipelines already exist.
Next step
If you are deciding which of these patterns fits your estate, or need to find where delay and fragmentation are costing you most, Beyond's AI Infrastructure Workshop works through these choices against your own data, helping you map freshness tiers, identify priority data products, and leave with a sequenced roadmap.











