How I'd structure a data function as a business grows: where the data people sit, and who builds the tables everyone shares, so the people using the data get an answer without first working out how the domains fit together.
Put data people where the data work is. Build each business concept once.
Early on, everyone sits in one central data team. At scale, data people move into the domains, and the shared tables get built one of two ways, depending on how strict you want the boundaries between domains to be. The blog post covers why data people belong close to the work.
Most product organisations are split into domains, and each domain into smaller areas with their own software and their own data. Architects call these bounded contexts. Billing and payments might both sit in a finance domain, for example. How far into them data people go depends on how much data work there is. Every product team also has a product analyst, who works on how people use the product, whichever stage you're at.
You don't start at scale. You start with everyone central, and move people out as each domain earns it. Both routes at scale end in the same place: tables built around business concepts, to a design that comes from the platform and data domain. That domain doesn't build the domains' data. It sets the standards they build to, and gives them a platform where following the standard is the easy option.
With platinum, the layer has to stay thin. Its only jobs are joining tables that already follow the design, and changing their level, such as rolling bills and payments up to a balance for each customer. The rules for those roll-ups, like what counts towards a balance, come from the domain that owns the data. Once the platinum team starts making those rules itself, it becomes another central team with a queue.
Most questions a business asks cross domains. How many live customers have a balance? Whether a customer is live sits with one team, and their balance with billing. If whoever asks has to find the pieces and join them, every question starts with that work, and two people soon get two answers. The blog post covers how that plays out.
So the layer most analysts use is modelled on the business, the way Ralph Kimball's conformed dimensions are. There's one customer table, at one row per customer, and anything known at the customer level goes on it, whichever team created it. Anything at a different level, such as each bill, goes on that concept's own table. History is kept at its own grain, as a daily snapshot or with an analysis date in the table. One concept at one grain keeps each table simple to read and hard to misuse.
I'd make these tables wide, with the joins and roll-ups already done. In an open columnar format like Delta or Iceberg, a wide table costs little, because a query only reads the columns it asks for. Large joins are the expensive part, and a join at the wrong grain quietly double counts. Doing the joins once, when the table is built, avoids both.
That matters even more for AI, because an agent finds everything about a customer in one table, with no joins left to get wrong. In a 2026 Berkeley benchmark of data agents, the best agent answered just over half its questions correctly first time, and giving agents a semantic layer raised their accuracy significantly.
Each table has one owner for its grain, its rules and its quality, and each team owns the columns it adds. Only attributes at a table's grain go on it, and columns nobody uses get retired. Every domain publishes through a contract that says what the data means, when it arrives and who owns it, so the analytics engineer in the team can check a change against it before it ships. Metrics follow the same pattern: one central framework that the domains add to, where a different definition gets a different name.
Early on, everyone in data reports into the Head of data. That's right while the team is small and sits together, because the person setting the standards can also see the work.
Once data people are spread across the domains, an analyst ends up with two bosses: the team that sets their work, and a manager in the data function who rarely sees it. So I'd move line management to the team. The engineering manager manages everyone in it, data people included.
What stays with the data function is the craft. Each data person keeps a dotted line to their discipline lead, who sets the standard, runs hiring, owns the career framework, feeds into every review and calibrates pay across the discipline. I'd rather the person managing you sees your work every day, and the person judging your craft does it for everyone in that discipline. In the platform teams, everyone reports to the team's EM, and the EMs report to the Head of data, who is then free to lead the data strategy and the design everyone builds to.
The first measure is how long someone waits for an answer after asking a data question. It should come down as data people move into the domains, because there's someone close by who knows the data. The second is how many metrics have more than one definition. It should fall towards none as the shared tables and the metric framework fill out. For the wider picture, the data maturity curve shows where the whole business sits.
This leans further into shared tables than Zhamak Dehghani, who first described data mesh, would. She'd rather each consumer build the view it needs, because big shared aggregates can grow unwieldy, and it's a fair worry. But hundreds of tables built by each consumer are unwieldy too, only spread out where it's harder to see. One grain per table and an owner for every column are how I'd keep the shared ones in check. Shared tables also take time to build. For a one-off question, building your own view can be quicker. The gain comes with every question after that.
This comes from scale-ups, where one product grows into many teams. In a large enterprise made of separate businesses, with little shared between them, a fuller data mesh may be the better fit, because there are fewer shared concepts to keep to one design.
One design needs someone to hold it. A good data architect makes it work, but if every change waits for their review, the queue comes back in a different place.
Moving line management only works if the engineering managers value the data work. If they don't, data people end up as spare engineers, and the discipline lead needs enough say to stop it.
And it depends on the software. If the product isn't split into domains with clear boundaries, the data can't be either, and no data structure will fix that.
This is my synthesis, from running a data function through each of these stages and from the sources below. The shared design comes from Kimball. How it gets built, by the domains on a self-serve platform, comes from data mesh.