<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Marina Cruceru on Medium]]></title>
        <description><![CDATA[Stories by Marina Cruceru on Medium]]></description>
        <link>https://medium.com/@marina.cruceru7?source=rss-8bbef0b704e7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*K-fQOcitQwte6_P6GpZ0pA.jpeg</url>
            <title>Stories by Marina Cruceru on Medium</title>
            <link>https://medium.com/@marina.cruceru7?source=rss-8bbef0b704e7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 15:19:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@marina.cruceru7/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Data Products in the Age of AI Agents]]></title>
            <link>https://medium.com/datafutures/data-products-in-the-age-of-ai-agents-9c9ed08611d9?source=rss-8bbef0b704e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c9ed08611d9</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[generative-ai]]></category>
            <category><![CDATA[data-product-creation]]></category>
            <category><![CDATA[modern-data-architecture]]></category>
            <category><![CDATA[semantic-layer]]></category>
            <dc:creator><![CDATA[Marina Cruceru]]></dc:creator>
            <pubDate>Thu, 22 Oct 2026 14:42:52 GMT</pubDate>
            <atom:updated>2026-10-22T14:42:52.066Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zo7aoaAsUgwVwqpgnfZvog.jpeg" /><figcaption>Even AI agents need a reliable base camp before they go exploring.</figcaption></figure><p>AI agents are now data consumers, and they don’t read between the lines. In this article I look at what that means for the data product. The semantic layer has been promoted: it’s now the translator between business meaning and machine action. Agents can help build it, but only with human guidance and supervision. Unverified, machine-written context can’t be trusted by other machines. The goal isn’t more governance theater. It’s a clear path from proposed meaning to trusted meaning, so your agents stop improvising and start delivering.</p><h3>The new consumer you didn’t design for</h3><p>In the first article, data products were compared to Lego bricks: small, independent pieces with clear connectors that snap together into something bigger.</p><p>In the second article, the focus moved inside the brick: facts, dimensions, semantic layers, and all the practical plumbing that makes a data product actually work.</p><p>Now it is time for the next awkward realization:</p><p>The next consumer of your data product may not be a human at all.</p><p>It may not be an analyst with a dashboard.<br>It may not be a data scientist with a notebook.<br>It may not even be that one heroic finance person who somehow understands all the joins better than the platform team.</p><p>It may be an AI agent.</p><p>And AI agents are not polite consumers.</p><p>They do not “kind of know” what your metric means because they sat through the same steering committee meeting. They do not read the comments in your transformation logic and nod thoughtfully. They do not send a Slack message asking whether “active customer” excludes test accounts this quarter.</p><p>They just consume what you expose.</p><p>Which means the bar for a good data product is changing again.</p><h3>A new kind of consumer walks into the room</h3><p>A lot of data products were designed with an unspoken assumption: eventually, a human would be involved to smooth out the rough edges.</p><p>A human could tolerate:</p><ul><li>A metric that is technically documented, but only if you already know where to look.</li><li>A column name that made sense to the person who created it three reorganizations ago.</li><li>Slight ambiguity in a definition because “everyone kind of knows what we mean.”</li><li>A freshness issue that gets spotted because a dashboard number feels weird.</li></ul><p>Humans are messy, but surprisingly forgiving.</p><p>AI agents are not.</p><p>They are very literal. They are very fast. They are very happy to take an incomplete or ambiguous product and turn it into a confidently wrong answer at machine speed.</p><p>That means the old standard of “good enough for a smart analyst to figure out” is no longer good enough.</p><p>A product that works for humans with tribal knowledge may completely fail when the consumer is an agent.</p><h3>From documented to self-describing</h3><p>For years, many data teams treated documentation as the nice-to-have spinach of the platform. Everyone agreed it was important. Almost nobody wanted to deal with it before dessert.</p><p>In the age of AI agents, documentation is no longer just for humans. It becomes part of the product itself.</p><p>A data product now needs to be self-describing.</p><p>That means an agent should be able to discover:</p><ul><li>What the product is for.</li><li>What business concepts it contains.</li><li>What its metrics mean.</li><li>How fresh it is.</li><li>What it can safely be joined with.</li><li>What level of trust or certification it has.</li><li>Who owns it.</li><li>When not to use it.</li></ul><p>And this information cannot live only in a wiki page, a forgotten PowerPoint, or in Brenda’s brain.</p><p>It has to be machine-readable and close to the product boundary.</p><p>This is where metadata stops being boring admin work and starts becoming survival gear.</p><p>Good metadata is how the agent sees the Lego connectors.</p><h3>The connectors have to be obvious</h3><p>The Lego analogy matters even more now.</p><p>A human can look at a weird brick and still improvise. An agent needs the studs and sockets to be obvious. It needs to know:</p><ul><li>Here are the inputs.</li><li>Here are the outputs.</li><li>Here are the identifiers.</li><li>Here are the allowed joins.</li><li>Here are the business meanings.</li><li>Here are the constraints.</li><li>Here are the policies.</li></ul><p>In a human-only world, a lot of those details were carried informally. People learned them over time, or asked around, or simply copied the SQL of the smartest person in the room.</p><p>That does not scale when agents are the consumers.</p><p>If you want an agent to use a Customer product and a Revenue product together, the connectors cannot be “well, technically they line up if you also know that customer_status = ‘A’ means active and if you filter out internal accounts and if you use the fiscal calendar table but not the old one.”</p><p>That is not a connector. That is a cry for help.</p><p>An agent-ready product has connectors that are explicit, consistent, and discoverable without folklore.</p><h3>The semantic layer just got promoted</h3><p>In the previous article, the semantic layer was described as the part that answers the questions people thought the warehouse had answered years ago.</p><p>That still holds.</p><p>But now the semantic layer has a new job: it becomes the translation layer between business meaning and machine consumption.</p><p>If an AI agent is going to answer business questions, trigger workflows, generate narratives, or combine products dynamically, it needs more than raw schemas. It needs business semantics in a form it can use reliably.</p><p>That means the semantic layer should capture things like:</p><ul><li>Certified metric definitions.</li><li>Business-friendly entity definitions.</li><li>Relationship rules between products.</li><li>Domain vocabulary and synonyms.</li><li>Valid filters and usage constraints.</li><li>Confidence and certification status.</li><li>Provenance, validation status, and accountability for semantic definitions — including those generated by agents.</li></ul><p>This does <strong>not</strong> mean every product needs a giant enterprise semantic bureaucracy wrapped in fifteen layers of governance theater.</p><h3>The Agent Bureaucrats</h3><p>Specialized agents can be capable assistants in creating and maintaining semantic layers and ontologies: proposing definitions, mapping business vocabulary, identifying inconsistencies, and flagging changes that need attention.</p><p>But capable does not mean self-certifying. Those agents need human enablement: appropriate tools, authoritative context, clear instructions, and explicit boundaries. They also need human-in-the-loop supervision, with accountable domain owners approving business meaning and reviewing consequential changes. It does <strong>not</strong> mean humans must manually write and maintain every definition.</p><p>Unverified machine-generated context cannot be considered agent-trustworthy. A definition does not become certified because an agent wrote it confidently — or because another agent agreed. Generated semantics must remain distinguishable from approved semantics until they have been validated.</p><p>It means the product boundary must carry enough meaning that a machine can interpret it without improvising nonsense.</p><p>The goal is not more semantic bureaucracy. It is a controlled path <strong>from proposed</strong> meaning <strong>to trusted </strong>meaning: agents can help draft and maintain it; humans remain accountable for what gets certified and used.</p><p>That is a higher bar than most teams are used to. But it is also a healthier one.</p><p>Otherwise, AI supplying context to AI without oversight is like letting the intern invent the accounting rules and then appointing their chatbot roommate as auditor. The paperwork may be immaculate. The numbers are still on an adventure.</p><h3>Observability is no longer optional</h3><p>When a human analyst uses bad data, there is at least a chance they notice.</p><p>The chart looks odd.<br>The number feels off.<br>The week-over-week jump seems impossible.<br>Someone in the meeting says, “That can’t be right.”</p><p>An agent may not get that moment.</p><p>If an AI agent consumes a stale, incomplete, drifted, or semantically broken product, it may continue cheerfully generating bad outputs, making recommendations, or triggering downstream actions with full robotic confidence.</p><p>Which is why observability matters so much more in the agent era.</p><p>A healthy data product should expose, monitor, and alert on things like:</p><ul><li>Freshness.</li><li>Schema drift.</li><li>Volume anomalies.</li><li>Null spikes.</li><li>Failed contracts.</li><li>Lineage breaks.</li><li>Quality rule violations.</li></ul><p>In other words, if the semantic layer tells the agent what the product means, observability tells the platform whether the product is still healthy enough to trust.</p><p>That combination is what moves a product from “technically available” to “safely consumable.”</p><p>And yes, that means observability is now part of product design, not an afterthought that gets bolted on after the third production incident.</p><h3>Governance has to run at machine speed</h3><p>This is where things get especially interesting.</p><p>A lot of governance in traditional environments still depends on human process:</p><ul><li>Review boards.</li><li>Approval meetings.</li><li>Documentation sign-offs.</li><li>Architecture councils.</li><li>Policy spreadsheets pretending to be controls.</li></ul><p>That already struggled with humans.</p><p>It definitely does not work when AI agents are discovering and consuming products in near real time.</p><p>If the consumer is a machine, governance has to become executable.</p><p>That means:</p><ul><li>Access policies must be enforced automatically.</li><li>Sensitive data must be classified and protected by default.</li><li>Certified products must be visibly distinguishable from experimental ones.</li><li>Contract violations must block or warn automatically.</li><li>Deprecated products must be marked in ways machines can detect.</li><li>Usage constraints must be encoded, not just politely suggested.</li></ul><p>This is the same theme that has shown up across the whole series: good governance is not centralized gatekeeping. It is clear, embedded guardrails that let decentralized products move quickly without turning the whole platform into chaos.</p><p>AI agents just make that truth impossible to ignore.</p><h3>Not every data product is agent-ready, and that’s okay</h3><p>One important nuance: not every product needs to be optimized for AI agents right now.</p><p>Some products are still internal, immature, highly exploratory, or too unstable to pretend otherwise. That is fine.</p><p>The goal is not to slap “AI-ready” on every dataset like it is a new flavor of yogurt.</p><p>The goal is to recognize that data products now have a new class of consumer, and to decide deliberately which products are fit for that kind of use.</p><p>A practical maturity path might look something like this:</p><ul><li><strong>Human-usable:</strong> understandable with some documentation and expert help.</li><li><strong>Product-usable:</strong> governed, stable, and reusable across teams.</li><li><strong>Agent-readable:</strong> machine-discoverable metadata, explicit semantics, clear contracts.</li><li><strong>Agent-trustworthy:</strong> quality monitored, policies enforced, safe for autonomous or semi-autonomous use.</li></ul><p>That progression is much more useful than arguing in abstract terms about whether a platform is “ready for AI.”</p><h3>A practical checklist: is your data product agent-ready?</h3><p>Here is the gut-check version.</p><h3>1. Can a machine discover what this product is?</h3><ul><li>Is the purpose clearly described in metadata?</li><li>Is ownership explicit?</li><li>Is certification status visible?</li><li>Is the product easy to find in a catalog?</li></ul><h3>2. Can a machine understand what the data means?</h3><ul><li>Are core entities and metrics defined explicitly?</li><li>Are business terms and synonyms captured?</li><li>Are valid joins and shared identifiers documented?</li><li>Are constraints and assumptions made visible?</li></ul><h3>3. Can a machine use it safely?</h3><ul><li>Are access rules enforced automatically?</li><li>Is sensitive data classified?</li><li>Are deprecated fields and products marked clearly?</li><li>Are experimental and certified versions distinguishable?</li></ul><h3>4. Can the platform tell when the product is unhealthy?</h3><ul><li>Are freshness and quality monitored?</li><li>Are schema and volume changes detected?</li><li>Are contract violations surfaced automatically?</li><li>Is lineage visible enough to trace issues?</li></ul><h3>5. Can the product evolve without confusing consumers?</h3><ul><li>Are versions explicit?</li><li>Are breaking changes managed deliberately?</li><li>Are compatibility expectations documented?</li><li>Are downstream impacts visible?</li></ul><p>If the answer to most of those is “not yet,” that does not mean the product is bad.</p><p>It just means it was probably designed for a world where humans were doing more of the interpreting.</p><p>That world is already changing.</p><h3>The real shift</h3><p>The biggest change is not technical. It is mental.</p><p>For years, data teams have designed products assuming the consumer would supply some missing context. A good analyst, a patient engineer, an experienced data scientist — someone would bridge the gap.</p><p>AI agents are much less generous.</p><p>They force us to move hidden context out of people’s heads and into the product itself.</p><p>In a weird way, that is actually a gift.</p><p>It pushes data products to become more explicit, more observable, more governable, and more honest about what they do and do not mean.</p><p>Which is probably what they should have been all along.</p><p>So yes, the next consumer you did not design for may be an AI agent.</p><p>The good news is that the same things that make a product safe for agents also make it better for humans.</p><p>Clear connectors.<br>Explicit meaning.<br>Visible health.<br>Governed access.<br>Thoughtful evolution.</p><p>Still Lego bricks. Just with a much pickier builder on the other side.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c9ed08611d9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/datafutures/data-products-in-the-age-of-ai-agents-9c9ed08611d9">Data Products in the Age of AI Agents</a> was originally published in <a href="https://medium.com/datafutures">Data Futures</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Data Products, But What’s Inside?]]></title>
            <link>https://medium.com/datafutures/data-products-but-whats-inside-979357e2f6a3?source=rss-8bbef0b704e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/979357e2f6a3</guid>
            <category><![CDATA[data-modeling]]></category>
            <category><![CDATA[data-mesh]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[data-architecture]]></category>
            <category><![CDATA[product-data]]></category>
            <dc:creator><![CDATA[Marina Cruceru]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 14:31:00 GMT</pubDate>
            <atom:updated>2026-09-10T14:31:00.833Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Uzmhj2-yhZpmE_VTndiL7Q.jpeg" /><figcaption>Like a spacecraft built from Lego bricks, a data product works because its internal components fit together with purpose.</figcaption></figure><p><strong><em>Data products are often described as reusable, discoverable, and ready for consumption — but what actually makes them work?</em></strong><em> This article opens the “brick” to examine the components within: trusted source data, well-designed facts and dimensions, clear business definitions, quality controls, and the connections that allow a product to be reused with confidence.</em></p><h3>A pragmatic look at modern Kimball</h3><p>In the first article, data products were compared to Lego bricks: small, independent pieces with clear connectors that snap together to build something bigger. That’s still the right picture from the outside.</p><p>But at some point, somebody always asks the next question: fine, but what’s actually inside the brick?</p><p>And the answer is: not magic.</p><p>Inside a good data product, there is still modeling. There is still structure. There is still the very unglamorous but absolutely essential work of deciding what a thing means, what level of detail it lives at, how it relates to other things, and how not to make your future self miserable.</p><p>So yes, this is where Kimball quietly sneaks back into the room.</p><p>Not “big central warehouse, one massive enterprise bus matrix, gather the kingdoms” Kimball. More like modern, pragmatic Kimball: scoped, useful, business-friendly modeling inside product boundaries.</p><p>In other words, the Lego brick still has some very sensible engineering inside it.</p><h3>A data product is not a random pile of tables</h3><p>Sometimes data product conversations get so excited about ownership, domains, and interoperability that modeling starts to sound optional. Like if the contract is clear enough, the inside can just be… vibes.</p><p>It cannot.</p><p>A data product may present itself as a neat black box from the outside, but inside it still needs a model that makes the product understandable, stable, and reusable. If that internal structure is weak, the product may still technically exist, but consumers will experience it the same way they experience most undocumented datasets: confusion, guesswork, and Slack messages that start with “quick question…”</p><p>That’s why old-fashioned modeling concepts still matter:</p><ul><li>What business process are we describing?</li><li>What is the grain?</li><li>What are the facts?</li><li>What are the dimensions?</li><li>Which attributes are stable, and which ones are going to cause drama later?</li></ul><p>That is not legacy thinking. That is just basic adult supervision for analytics.</p><h3>Modern pragmatic Kimball</h3><p>This is the part where some people get nervous, because “Kimball” can sound like a gateway drug back to giant centralized warehouse programs that take 18 months and produce a glorious diagram nobody wants to maintain.</p><p>That is not what this is.</p><p>Modern pragmatic Kimball keeps the parts that still work:</p><ul><li>Start with the business process.</li><li>Be explicit about grain.</li><li>Separate measurable events from descriptive context.</li><li>Use dimensions and facts when they make things clearer.</li><li>Model for the questions people actually need answered.</li></ul><p>What gets left behind is the assumption that the entire enterprise needs to line up inside one grand, centrally governed dimensional masterpiece.</p><p>Instead, the dimensional model lives where it creates value: <strong>inside</strong> the data product, for the consumers that product serves.</p><p>A Sales Analytics product may absolutely have a clean fact table for orders and a set of dimensions for customer, product, channel, and date. That is not old-school dogma. That is just good modeling. The trick is that it is scoped to the product boundary, not imposed as the foundation for every other domain in the company.</p><p>So yes, Kimball is still invited to the party. He just doesn’t get to redesign the whole house.</p><h3>Product boundaries change the job of modeling</h3><p>Once you start thinking in data products, modeling gets more focused and, honestly, more realistic.</p><p>In the old enterprise warehouse mindset, the model was often trying to become the universal truth for the whole business. That sounds noble right up until Marketing, Finance, Operations, and Product all use the word “customer” and mean four different things.</p><p>Inside a data product, the job is simpler:</p><ul><li>Model one domain well.</li><li>Be clear about what the product owns.</li><li>Expose a contract that other products and consumers can understand.</li><li>Use shared connectors — domain identifiers, reference data, standards — so the product can play nicely with others.</li></ul><p>This is where the Lego analogy still works beautifully. Each brick has its own internal structure. Some are wide, some are narrow, some are simple, some are surprisingly elaborate. But what makes them useful is not that they all look the same inside. It’s that they connect cleanly on the outside.</p><p>That means you do <strong>not</strong> need one giant enterprise star schema to get interoperability. You need clear product boundaries and a small set of shared rules for how products line up with each other.</p><p>That is a much more achievable goal, and a much less soul-crushing one.</p><h3>What’s usually inside the brick</h3><p>A useful data product often has a few internal layers, even if you don’t call them that out loud in meetings because everyone is tired of architecture bingo.</p><h3>1. Source-ish layer</h3><p>This sits close to the firehose, but it is not always just raw tailpipe data dumped straight from the upstream system.</p><p>It can include:</p><ul><li>Raw extracts from source systems.</li><li>De-queued business events.</li><li>Inputs consumed from upstream data product contracts.</li><li>A combination of source data and outputs from other data products.</li></ul><p>Think of this as the place where the product’s inputs first snap together. The Lego connector idea matters here: some inputs arrive as rough bricks straight from the factory, others arrive as already-shaped bricks from upstream products. Either way, they need compatible connectors — clear IDs, known structures, defined events, usable contracts — so the product can assemble them without duct tape and prayer.</p><p>This layer is usually a little messy, but it should still be traceable. When someone asks, “Why is this number weird?”, this is where you go to follow each piece back to its original brick.</p><h3>2. Harmonized or domain layer</h3><p>This is where the product starts speaking its own language.</p><p>Types get cleaned up. Codes get standardized. Dates stop pretending to be strings. Business rules start to appear. Source system oddities are smoothed out into domain concepts that people can actually work with.</p><p>This is often the most valuable part of the product, especially for AI agents, data scientists, advanced analytics teams, and anyone who wants flexibility without descending into raw-data archaeology.</p><p>If the source-ish layer says, “Here is what came in,” the harmonized layer says, “Here is what it means in this domain.”</p><h3>3. Curated analytical layer</h3><p>This is where dimensional thinking often shines.</p><p>Not every product needs a formal star schema, but many analytics-heavy products absolutely benefit from one. When users want stable measures, drill paths, and consistent slicing across time, geography, customer, product, or channel, a curated fact-and-dimension structure still works very well.</p><p>This is where modern Kimball earns its keep.</p><p>Done well, this layer makes the product easy to query, easy to explain, and much harder to misuse. Which, in analytics, is basically an act of public service.</p><h3>4. Semantic layer</h3><p>This is the layer that answers the questions people thought the warehouse had answered years ago.</p><ul><li>What exactly is “active customer”?</li><li>What counts as “net revenue”?</li><li>What makes an order “complete”?</li><li>When does a member become inactive?</li><li>Which margin are we talking about today?</li><li>And, for an AI agent: which definition is certified, current, appropriate for this question, and safe to use?</li></ul><p>The semantic layer is where those definitions become explicit, governed, and machine-readable. It may live in views, metrics definitions, catalog entries, semantic tools, or a mix of all of the above. However it is implemented, its job is the same: make the product understandable and trustworthy at the boundary. It needs to carry more than calculation logic: ownership, certification status, lineage, freshness and quality signals, permitted joins, and access constraints give an AI agent the context to interpret and use the product safely.</p><p>Without this layer, even a beautiful model becomes a confidence game — and AI agents are exceptionally good at playing it with confidence..</p><h3>Where dimensional modeling still fits</h3><p>There is a strange tendency in modern data conversations to treat dimensional modeling like a fax machine: old, embarrassing, and maybe still lurking in the basement.</p><p>But dimensional modeling is not obsolete. It is just no longer the answer to every question.</p><p>It works especially well when:</p><ul><li>The product serves recurring analytical use cases.</li><li>Consumers need stable business measures.</li><li>Data is sliced repeatedly across shared descriptive attributes.</li><li>Performance and usability matter.</li><li>The business process is well understood.</li></ul><p>It works less well when:</p><ul><li>The product is mostly event-driven and exploratory.</li><li>The structure is highly fluid.</li><li>The main need is traceability and flexibility rather than polished analytics.</li><li>The domain is still too immature to pretend a clean star schema won’t collapse in two weeks.</li></ul><p>That is why “modern pragmatic Kimball” is a good phrase for this moment. It acknowledges that dimensional techniques are still powerful, but they are now one tool inside a product, not the theology of the entire platform.</p><ul><li>So yes, sometimes the answer is a star schema.</li><li>Sometimes it is a wide, carefully governed analytical table.</li><li>Sometimes it is a hybrid.</li><li>Sometimes it is “please calm down, we are not ready for that yet.”</li></ul><p>Pragmatism is the point.</p><h3>A simple way to think about it</h3><p>If the first article said data products are like Lego bricks, this follow-up says the inside of each brick usually contains some combination of:</p><ul><li>Input connectors.</li><li>A bit of plumbing.</li><li>Structural support.</li><li>A shape designed for a purpose.</li><li>And, if you built it well, enough order that the next person can use it without needing a therapy session.</li></ul><p>That is really what modeling inside a data product is about.</p><ul><li>Not building the perfect enterprise abstraction.</li><li>Not forcing every domain into the same shape.</li><li>Not pretending the old warehouse problems vanish if we rename enough layers.</li></ul><p>Just building internal structure that is clear enough, practical enough, and stable enough that the product can do its job well.</p><h3>A pragmatic checklist: what should be inside a data product?</h3><p>When designing the inside of a data product, this is a useful gut-check:</p><ul><li>Is the business process clear?</li><li>Is the grain explicit?</li><li>Are the core facts and dimensions obvious?</li><li>Can the product trace inputs back to sources or upstream products?</li><li>Are domain concepts harmonized before they are exposed?</li><li>Are curated analytical structures added only where they create real value?</li><li>Are business definitions explicit at the boundary?</li><li>Are identifiers and shared references aligned with enterprise standards?</li><li>Can consumers understand what the product means without reverse engineering it?</li><li>Can the product evolve without breaking every downstream consumer?</li></ul><p>If the answer to most of those is yes, the brick probably has something solid inside it.</p><p>And that is the real point.</p><p>Data products may look modern, modular, and sleek from the outside. But on the inside, the good ones are still built on thoughtful modeling, clear semantics, and a healthy respect for the fact that data does not organize itself just because the platform has a shiny new name.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=979357e2f6a3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/datafutures/data-products-but-whats-inside-979357e2f6a3">Data Products, But What’s Inside?</a> was originally published in <a href="https://medium.com/datafutures">Data Futures</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Data Modeling for Data Products]]></title>
            <link>https://medium.com/datafutures/data-modeling-for-data-products-fa5e8e94cb51?source=rss-8bbef0b704e7------2</link>
            <guid isPermaLink="false">https://medium.com/p/fa5e8e94cb51</guid>
            <category><![CDATA[agile-data-modeling]]></category>
            <category><![CDATA[data-architecture]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[data-modeling]]></category>
            <category><![CDATA[product-data]]></category>
            <dc:creator><![CDATA[Marina Cruceru]]></dc:creator>
            <pubDate>Tue, 10 Feb 2026 12:10:50 GMT</pubDate>
            <atom:updated>2026-02-10T12:10:50.575Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mZnnrmAgNfUgANWEaX3xVw.jpeg" /></figure><p><strong><em>Data modeling gets interesting when you stop thinking about warehouses and start thinking about products. Design your data like Lego bricks: small, reliable pieces that evolve independently and still snap together cleanly.</em></strong></p><p>Data modeling sounds dry until you realize it’s basically “designing how your data product thinks about the world.” Once you stop worshiping the Big Central Warehouse and start thinking in products, modeling gets a lot more interesting (and honestly, more fun). You shift the focus to the agile development of product capabilities and driving real business outcomes in small, iterative steps, while accepting that most organizations already operate in a messy, federated reality rather than a perfectly centralized one. That mindset naturally pulls you away from traditional, rigid enterprise-wide modeling dogma and toward a world of smaller, domain-owned data products that can evolve quickly without breaking everything else.</p><p>Think of data products as Lego bricks, not just tables in a big database.</p><p>Old-school data warehouses felt like one giant, <a href="https://medium.com/datafutures/the-anti-monolith-e48ca07c90c3">monolithic build</a>: impressive, but hard to change without knocking something over. A data product, by contrast, is more like a Lego brick. You see its input studs and output studs — its interfaces and guarantees — but you don’t need to know exactly how it’s built inside to use it correctly. Each brick can have a different color and shape (different schemas, technologies, and internals), yet all expose a well-defined way to connect to other bricks.</p><p>Your data platform then becomes a Lego model: a composition of independent data products that encapsulate their sources, transformations, and outputs. The same brick can play different roles in different builds — a “Sales Orders” product might be part of a financial reporting model in one context and a churn prediction pipeline in another. The power doesn’t come from one perfect master piece, but from having small, reliable pieces that click together cleanly whenever you need to build something new.</p><h3>1. Start from the product, not the warehouse</h3><p>Old world: “Let’s dump everything into the warehouse, model it perfectly, and someday people will use it.”</p><p>New world: “Who’s the customer for this data product and what do they actually need?”</p><p>You begin with real use cases and real people:</p><ul><li>Are you feeding dashboards, ML models, reverse-ETL, operational APIs?</li><li>What are the handful of questions this product must answer on demand?</li><li>What “promises” do you want to make about freshness, completeness, and meaning?</li></ul><p>Once you know that, the model becomes a way of keeping your promises, not an abstract diagram you show in architecture reviews once a year.</p><p>Think of it like building a coffee machine, not a plumbing museum: your users care about “espresso now,” not “look at all these beautiful pipes.”</p><h3>2. Domains and boundaries</h3><p>In data product land, you don’t design The One True Enterprise Model. You design a bunch of smaller, domain-shaped models that actually match how the business works.</p><p>Each product is a little world:</p><ul><li>A “Orders” product owns what an order is, how it behaves, and how you measure it.</li><li>A “Customers” product owns customer data and its life cycle.</li><li>A “Billing” product owns invoices, payments, and so on.</li></ul><p>Inside each world, you’re allowed to speak that domain’s language. “Customer” in Marketing may not be the same as “Customer” in Billing — and that’s okay, as long as the boundaries are explicit and the interfaces are clear, and appropriately named.</p><p>Global, canonical, everyone-must-agree models sound great until you try to get Sales, Finance, and Marketing to agree on “revenue.” Data products sidestep that fight: each domain owns their definition, and you document it instead of pretending it’s all the same.</p><h3>3. The layers inside a data product</h3><p>Even inside a single data product, you don’t just throw everything into one giant table called `facts_and_stuff`.</p><p><a href="https://medium.com/datafutures/medallion-architecture-in-a-data-product-world-3758d17b6cf6">A lightweight structure</a> usually looks like this:</p><ul><li>Source-ish layer: This sits close to the firehose but isn’t just a raw data dump. It can pull in truly raw “tailpipe” data straight from upstream systems, but also de‑queues well‑defined events and consumes from the explicit data contracts of upstream data products — like Lego bricks snapping together via matching connectors. It’s still a bit messy, but everything is traceable back to its original brick, which makes it the perfect place to chase down all those “why is this number weird?” questions.</li><li>Clean, domain-shaped layer: Types fixed, units aligned, codes normalized, timestamps sane, names human-readable. This is your “silver-like” core.</li><li>Consumer views: Friendly layouts tailored for actual use cases — analytics, ML, exports, APIs — while still sticking to the product contract.</li></ul><p>On top of that, you add a semantic layer: what’s an Order, what’s a Customer, how are they related, and what do metrics like Revenue, MRR, or Churn actually mean.</p><p>Your goal isn’t to create 47 perfectly normalized layers. It’s to make sure a reasonably smart human (or ML engineer on too much coffee) can look at your product and say, “I get what this means and I can trust it.”</p><h3>4. Making products play nicely together (without rebuilding the EDW)</h3><p>If every team models their product independently, you could end up with chaos. The trick is to keep some shared rules so the products can actually be combined.</p><p>That means agreeing on a few boring but crucial things:</p><ul><li>Identifier rules: how `customer_id`, `order_id`, and friends behave across products, aligning on domain identifiers and using them consistently so everything actually snaps together instead of needing heroic joins later.</li><li>Shared reference stuff: currencies, country codes, product hierarchies.</li><li>Event patterns: if multiple domains emit lifecycle events, they should follow the same basic structure.</li><li>Naming and classification that doesn’t make your catalog look like a junk drawer.</li></ul><p>Within those guardrails, each domain is free to model as they see fit. You don’t need one massive “Enterprise Conceptual Data Model” poster on the wall; you need a small set of rules that lets you join products together without tears.</p><p>Think of it as city planning: you can design your own house, but you still have to connect to the same road system and power grid.</p><h3>5. Models that grow up, not lock up</h3><p>In the warehouse era, changing the model was a bit like open-heart surgery. Everyone knew it was necessary; nobody wanted to schedule it.</p><p>With data products, your model is allowed to evolve — as long as you treat it like a versioned product, not a random side effect:</p><ul><li>You start with a v1 contract: here’s the schema, here’s what the fields mean, here’s how fresh and complete it will be.</li><li>When you add new stuff, you try to do it in non-breaking ways first (new columns, new views, new metrics).</li><li>When you *have* to make a breaking change, you ship a v2 alongside v1, give people time to switch, and only then retire the old one.</li></ul><p>Governance is there, but it’s not just a committee in a meeting room. It’s encoded in tests, checks, and rules in your pipelines and platform. If you try to sneak in a breaking change on a Friday afternoon, the system should yell at you before your users do.</p><h3>Practical checklist for modeling a new data product</h3><p>Here’s a quick, copy-pastable checklist to help you design your Data Products.</p><h3>1. Who is this for and why does it exist?</h3><ol><li>List your main consumers (teams, roles, systems).</li><li>Write down 5–10 core questions or jobs this product must support.</li><li>Decide what “good enough” means for freshness and completeness.</li></ol><h3>2. What domain does it belong to?</h3><ol><li>Name the domain (Orders, Claims, Patients, Marketing, etc.).</li><li>List what this product owns and what it definitely does NOT own.</li><li>Note which other products it will depend on.</li></ol><h3>3. Sketch the model (no tools yet)</h3><ol><li>Identify the main entities and events.</li><li>Draw how they relate (boxes and arrows are fine).</li><li>Call out the important attributes and keys.</li></ol><h3>4. Define the contract</h3><ol><li>Decide which tables/views are public and which are internal.</li><li>Write plain-language definitions for key entities and metrics.</li><li>Specify the schema, types, and constraints you’re willing to guarantee.</li><li>State your SLAs (freshness, availability, quality).</li></ol><h3>5. Make it interoperable</h3><ol><li>Align domain identifiers and reference data with whatever your org uses as standards.</li><li>Check that it can join cleanly with your most likely neighbor products.</li><li>Apply consistent naming so someone in the catalog can recognize what it is.</li></ol><h3>6. Build the inside layers</h3><ol><li>Create a source-aligned layer to keep upstream reality visible.</li><li>Build a cleaned domain layer with business-friendly semantics.</li><li>Expose consumer views that match how people will actually query it.</li></ol><h3>7. Bake in governance and quality</h3><ol><li>Tag sensitive fields (PII, PHI, finance-critical, etc.).</li><li>Add tests: uniqueness, referential integrity, “this metric should never be negative,” and so on.</li><li>Enforce data contracts , programmatically ensuring that products gracefully evolve and don’t break downstream consumers.</li><li>Register the product, its owner, and its schema in your catalog.</li></ol><h3>8. Plan for change</h3><ol><li>Decide how you’ll name and manage versions (v1, v2, etc.).</li><li>Write down what counts as a breaking change.</li><li>Document how long you’ll keep old versions alive after a new one ships.</li><li>Establish a deprecation timeline</li></ol><h3>9. Reality check with users</h3><ol><li>Walk real consumers through the model and sample queries.</li><li>Ask what’s confusing, what’s missing, and what’s overkill.</li><li>Adjust before you declare v1 “done.”</li></ol><h3>10. Monitor and iterate</h3><ol><li>Track usage: which tables, which fields, which queries.</li><li>Watch quality and performance over time.</li><li>Improve the model in response to real-world demand, not just architectural ideals.</li><li>Perform impact analysis before major changes so you understand which downstream products, reports, and systems you’re about to shake up.</li><li>Proactively work with dependent teams, give them clear deprecation timelines, and encourage them to adopt the newer versions so your data product can keep evolving without leaving a trail of broken consumers behind.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fa5e8e94cb51" width="1" height="1" alt=""><hr><p><a href="https://medium.com/datafutures/data-modeling-for-data-products-fa5e8e94cb51">Data Modeling for Data Products</a> was originally published in <a href="https://medium.com/datafutures">Data Futures</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>