One product record can get two verdicts on the same day. Purchasing reads description, base unit, supplier and lead time, finds all four filled and correct, and rates the record good. Costing reads description, standard cost and valuation class, finds standard cost empty and valuation class wrong, and rates the same record bad. Neither is wrong, because data quality is fitness for use.
Product data quality gets fixed at the moment a product is created, and it stays fixed when someone owns it afterwards. A clean-up project that corrects today’s errors works for a quarter and then decays, because the process that creates the data has not changed. Quality holds when it moves from a reactive pattern, where errors are found and fixed downstream, to a proactive one, where checks and owners sit at the point of creation.
The scenario draws on an architecture workshop I recently designed for a manufacturer whose product data runs through a PLM system and an ERP system, with ESG data arriving from further sources on a data platform built with dbt. This post walks through why quality has to turn proactive, the outcomes to aim for, the challenges that keep breaking it, and how a Product data product addresses them.
The scenario is an engineering one, and two kinds of system dominate product creation. A PLM (product lifecycle management) system is where engineers design and release the product: its parts, structure, revisions and engineering changes, under rigid change control. An ERP (enterprise resource planning) system is where the same product becomes a material that purchasing, production, logistics and finance use, with units of measure, lifecycle status and cost.
These two are the most prominent silos in product creation, and many other constellations of software produce the same problems: different keys, units and statuses, unclear ownership, and changes that do not reach every system. Read the examples as patterns, and substitute whichever systems sit in your own product creation process.
Why this only succeeds when quality turns proactive
Nothing in this post pays off until data quality moves from a reactive pattern to a proactive one. A reactive pattern finds errors downstream, in a report, an order or an invoice, and corrects them after the damage. The fix list grows, a clean-up project shrinks it for a while, and new errors refill it, because the process that creates the data has not changed.
A proactive pattern moves the check to the moment of creation. The same rules that assess existing data also run when a product is created in the PLM or ERP system, so errors are stopped at the source. Every attribute has a named owner, every rule is versioned with a purpose, and errors carry the process, attribute and creator, so the team that creates a problem sees it and can change how it works.
The measurement follows the same logic. Reactive work is judged on the size of the backlog, which falls when someone corrects old records and says little about the next product. Proactive work is judged on the trend for newly created products, which predicts how clean the next record will be. That is why the platform keeps new and inherited errors apart, and why ownership has to be anchored before the clean-up ends.
Four outcomes the solution has to deliver
The target is a solution template with four parts, and Product is the first domain to use it. Other data products then reuse what Product proves.
- A rule catalogue. Rules link each attribute to the processes it supports, so we can see how ready the data is to run them and where quality must improve.
- An assessment per process. Each process gets a current picture and a trend. Processes may see quality differently, and the assessment shows why their views differ.
- Hotspots and their source. The data shows where problems arise and who creates them, so changes can target the data birth process directly and stay surgical instead of broad.
- First time right, and a fix list. New data is right when it is created. Existing errors arrive as a prioritised list, so effort goes where it counts.
Four questions open the conversation with the business. Which processes are under the most pressure, and which attributes cause the problems? Who creates the errors today? How do we keep new products apart from inherited ones? How do we turn error lists into something people can act on? Separating new from inherited errors is the check on whether quality is improving at the source.
Name the capabilities before the tools
The first design step is a list of capabilities, not systems, because it keeps the argument on where boundaries sit instead of which tool does what. Data flows through four steps, and a rule catalogue with governance runs across all of them.
- Source. The PLM and ERP systems with checks at creation, plus the ESG sources.
- Land. Raw and immutable, so any load can be re-run without going back to the source.
- Conform. Renamed and typed into the business’s own terms, with one governed record per product.
- Read. Operational readers get current state through an API or a view. Analytical readers, which include people, models and agents, get current and historical data, versioned and modelled for consumption.

The rules apply at every step, from checks at creation in the source systems to the assessment on the analytical path.
The rule catalogue gives each attribute and process a rule with a named owner. It records what the rule declares beside what the platform observed. One boundary needs an explicit decision: whether conform sits inside the integration layer or beside it.
Where product data quality breaks
Dispersed product creation produces eighteen recurring challenges in three groups: systems, sources and ownership (eleven), creating and changing products (four), and timing and trust (three). Each is easier to prevent at creation than to fix later, because a product that is already active is hard to correct. Checks at creation and a named owner per attribute stop errors from entering.
Twelve of them follow, with the mitigation for each. The Appendix tab lists all eighteen.
| Challenge | What goes wrong | Mitigation |
|---|---|---|
| Keys do not match | ERP material numbers and PLM part numbers are matched by hand or not at all, which produces duplicates and orphans. | Keep an explicit product-to-part link in the Product domain with a named maintainer. Cross-system checks run against the link, so a real gap separates from a missing link. |
| Unit abbreviations differ | The same unit of measure is written two ways in the PLM and ERP systems, so a check fails although both mean the same unit, and false errors reach the fix list. | Map the abbreviations once in conform, in one mapping with a named maintainer. Rules run on the conformed value. |
| Lifecycle status is out of step | A product is released in the PLM system but still blocked or in preparation in the ERP system, or the other way round. | Decide which status is leading and how long the systems may differ. The assessment then shows whether a gap is an error or a step still to come. |
| Write-back to the ERP system is blocked | A lock mechanism stops corrections once a product is active, the unit of measure being the classic case. Creating a new product is easier than fixing one in use, so duplicates appear. | Check at creation so the error never enters. Mark errors that cannot be written back as their own class on the fix list, with a decided correction route. |
| Finance attributes sit in the PLM system | Engineers have little interest in attributes such as spend class, so mandatory fields fill with random values that pass the check and mean nothing. | Give financial attributes an owner with a stake in them, and decide where they are entered. Use checks that test the value, not only that the field is filled. |
| Changes are made downstream | An attribute created in the PLM system is changed in the ERP system because that is easier, and a later PLM change can overwrite it. | Decide where each PLM-created attribute must be changed. Compare the PLM and ERP values in the assessment so divergence is visible before an overwrite. |
| Bought products skip engineering | Consumables are created in the ERP and procurement systems with no engineering review, so nothing checks the master data. | Name an owner for bought-product master data, and apply the same creation rules in the ERP and procurement systems. |
| ESG data arrives from outside | Supplier figures come with unclear units and gaps, and nobody internal follows up. | Write an inbound contract for what the supplier must send, reject structural failures at integration, and name an internal owner for gaps. |
| Mass changes | A supplier change, a rename or a new regulation touches thousands of products, and the normal process handles them one at a time, so errors stay in place or are fixed unevenly. | Provide a controlled route for changing many products together, with a named approver. |
| Copied products | A clone carries the errors and outdated values of the original, and looks complete, so nobody checks it again. | Decide which attributes are never copied, and run the creation checks on a copied product like any other. |
| Different definitions of complete | Engineering, procurement and finance each have their own idea of a finished record, so the same product shows different quality. | Hold rules per process, name who decides what complete means, and read the assessment per process. |
| Changes without a trail | Nobody can say who changed an attribute, when or why, so errors cannot be traced to where they were created. | Decide which changes must be logged and where the log is kept. Store test results in an audit log per process, attribute and creator. |
Each challenge ends in a question for the business. Which checks and owners belong in the creation process? How should the fix list treat errors that cannot be written back? Who decides what complete means?
What the data product solves, and what it cannot
A platform removes the technical causes of poor quality and makes the rest visible, but whether quality is kept up depends on decisions only the business can take. Sorting the eighteen challenges makes that split concrete.
| Solved by the platform | Made visible by the rules | Needs a decision from the business |
|---|---|---|
| Unit abbreviations | Write-back to the ERP system | Bought products |
| Same product, different keys | Lifecycle status | ESG data from outside |
| Revisions versus materials | Change control in the PLM system | Finance attributes in the PLM system |
| Variants and configurations | Changes downstream of the PLM system | Ownership changes |
| Changes without a trail | Mass changes | Definitions of complete |
| Copied products | Legacy products | Data that is right too late |
The left column is conformed once into one governed record per product. The middle column is measured and listed through the assessment, the hotspots and the fix list. The right column is owned by people: who owns, and who decides. This is a first view, to confirm with the business.
Why AI changes product creation
AI changes product creation because it can act at the moment of creation, which is where a proactive pattern needs the work done, and it depends entirely on the governed record underneath it. Rules tell a creator what is wrong after the value is typed. An AI assistant can help before and while it is typed, at a scale no data steward team could cover by hand.
Four uses stand out in the scenario above:
- Assisted creation. When a product is created or copied, an assistant proposes values from comparable products, flags attributes that should never be copied, and explains in plain language which rule a check comes from. A proposed value that the owner confirms replaces the random value that engineers type into a field they have no interest in.
- Mapping and matching. The two mappings that usually stay manual, unit abbreviations between systems and the link between PLM parts and ERP materials, can be proposed by AI as candidates. A named steward confirms them, because matching is mastering and someone has to own the result.
- Mass changes. A supplier change or a new regulation touches thousands of products. An assistant can draft the change set across all of them, and a named approver releases it.
- The fix list. Each failed check can come with an explanation and with what the correcting user needs to bring, and the list can be ranked by priority. That turns an error list into work people can act on.
The same logic applies to reading. The Product domain is exposed as one semantic model with the whole product context, so AI agents can ask across the whole product, and they read grain and meaning straight from the contract files in the repo.
That dependence sets the condition. An agent that reads inconsistent keys, undefined attributes and unowned rules produces confident answers that are wrong, and it spreads them faster than any report could. Contracts, named owners, an audit trail and rules per process are what make an AI assistant reliable, and they are also what the rest of this post argues for. Build them first, and AI turns a proactive pattern from a discipline people have to remember into something the process does by default.
How the Product data product is built
The Product data product is the one place where quality is defined, measured and acted on. The rules, assessment, hotspots and worklist all read from the same governed record, so processes stop keeping their own checks and views of quality stop drifting apart.
Three design choices carry it. First, an integration layer does only mechanical work: it lands data raw and replayable, conforms it into one business vocabulary, and exposes it through one interface that every reader takes from. Anything the business owner would have an opinion about, such as business rules, derived attributes and merging across sources, stays out of that layer. Second, the Product domain is built once on the data platform, conformed across sources and historised, and exposed as one semantic model that analytics and AI agents slice as they need. Third, metadata lives in the repo: contracts, models and quality rules are declared in dbt YAML and versioned in Git, enforced by the component that writes the data, and only read by the catalogue.
The Appendix tab holds the technical detail.
Three things to find out, and a foundation to build on
None of this is a verdict on current data quality. It is a set of three questions to answer together with the business, and the answers shape the template.
Views of quality differ
The opening example shows the effect: one material record, two verdicts, because each process judges the fields it depends on. A single quality score for the record hides this, and an enterprise-wide figure such as “92 percent complete” is a typical example. The assessment per process makes the differences visible and shows whether they come from different use of attributes or a different understanding of the product attribute domain.
Hotspots and their source
One heatmap answers three questions. Each row is an attribute, each column a consuming process, and each cell the number of errors that process hit on that attribute. With illustrative numbers, the column totals show which process is under most pressure (costing at 58 errors, then logistics, purchasing and sales). The row totals show which attributes cause the problems (standard cost at 42, weight and size at 35). Placing the creating team beside each attribute shows who creates the errors. In the example, product engineering owns two problem attributes that add up to 61 errors, more than any other team, and that only appears once creators sit beside attributes.
New and inherited errors
Keeping new products apart from existing ones tells you what each trend means. Improving old registrations show that clean-up works, which is corrective work that ends when the backlog is empty and says little about the next product. Improving new registrations show that prevention works: creation rules, ownership and feedback are stopping defects before they enter. That trend predicts how clean the next record will be.
From per-process stacks to shared capabilities
If each process carries its own extract, logic, model and checks, effort is repeated and quality is read differently. The target is a set of shared capabilities that each new process adds to instead of building beside. I group them as seven:
- Common integration patterns: land, conform and expose, done the same way for every source.
- Entities built once, so Product and its attributes are governed entities every process can use.
- Contracts on every product: what each source sends, what each product promises and which rules apply.
- One shared dbt project, with models declared in dbt, built and tested on the data platform, and dependencies generated.
- Observability by default: reconciliation on every load, alerts to a named owner and replay from raw.
- Catalogue and access, so products can be found, understood and requested without asking the team that built them.
- A prioritised worklist for correction, which also tells the correcting user what to bring in order.
Some of these capabilities exist in parts today. The aim is to make them common, and Product goes first so that what works there becomes the template for the next data product. In practice that means taking an existing landing and raw pattern one step further: standardise the conform steps, set one format and naming for what is exposed, and build all of it alongside what runs today. Existing routes keep running, and a consumer moves only once the new path is proven.
What to do next
Three steps turn this from an architecture into a working practice.
- Map where products are created and who owns each attribute. Start with the systems that matter most, which in an engineering scenario usually means the PLM and ERP systems, and name an owner for every attribute that causes problems.
- Run the same rules at creation and on existing data. Put the checks for the first few attributes into the creation process, keep error lists for new and inherited products apart, and give each correcting user a prioritised worklist.
- Judge progress by the trend for new products. A falling backlog shows that clean-up works. A rising share of products that are right at creation shows that prevention works, and that is the number that predicts the next record.

Leave a Reply