DEV Community

Cover image for Building a Localization Pipeline for EU Digital Product Passport Data
Diogo Heleno
Diogo Heleno

Posted on Originally published at m21global.com

Building a Localization Pipeline for EU Digital Product Passport Data

The EU's Digital Product Passport (DPP) is one of those regulations that looks like a legal problem until you actually start implementing it, and then it turns into a very concrete data engineering problem. You end up with structured product data, multiple target languages per market, a QR code pointing to a live endpoint, and a compliance deadline. That's a systems design challenge, not just a translation task.

The M21Global article on DPP translation requirements does a good job covering the regulatory side: which documents need what level of review, and why a mistranslated substances-of-concern field can trigger a non-conformity rather than just a bad review. This post covers the other half: how to actually build the pipeline that keeps multilingual DPP content in sync with your product data as it changes.

Why this isn't a normal i18n problem

If you've built multilingual product pages before, your instinct is to treat this like standard i18n: extract strings, send to a translation service, get them back, render per locale. DPP content breaks that model in a few ways:

  • It's not UI copy, it's regulatory data with legal weight. A translated field isn't just displayed, it's audited.
  • It needs to stay tied to structured formats (XML/JSON) that feed ERPs, catalogue systems, and the actual QR code endpoint.
  • Different fields have different risk levels, so they can't all go through the same translation/review tier.
  • Source content changes continuously as products get updated, recalled, or re-certified, so this is a living pipeline, not a one-time export.

So instead of a string-extraction tool, think of this as a content sync problem between your PLM/ERP system, a translation layer, and whatever renders the public-facing passport.

Structuring the data so translation doesn't break it

First problem to solve: keep translation changes scoped to translatable fields only, and never touch structure, units, or identifiers.

A reasonable schema separates regulatory fields from descriptive fields explicitly, so you can route them differently later:

{
  "product_id": "SKU-48213",
  "category": "regulatory",
  "field": "substances_of_concern",
  "source_lang": "pt",
  "value": "Contém 0,08% de ftalato de dibutilo (DBP)",
  "translatable": true,
  "risk_level": "high"
}
Enter fullscreen mode Exit fullscreen mode
{
  "product_id": "SKU-48213",
  "category": "descriptive",
  "field": "marketing_description",
  "source_lang": "pt",
  "value": "Cadeira ergonómica fabricada com materiais reciclados",
  "translatable": true,
  "risk_level": "low"
}
Enter fullscreen mode Exit fullscreen mode

The risk_level field is the key addition. It lets you route content programmatically to the correct review tier instead of deciding manually per document, which doesn't scale past a few hundred SKUs.

Routing content by risk level

Once fields are tagged, you can build a simple router that decides the translation workflow:

def route_for_translation(field):
    if field["risk_level"] == "high":
        return "TEP"       # translate + edit + proofread, second linguist review
    elif field["risk_level"] == "medium":
        return "MTPE"      # machine translation + full post-edit
    else:
        return "MT_light"  # light post-edit or no review

for field in product_fields:
    if field["translatable"]:
        workflow = route_for_translation(field)
        queue_for_translation(field, workflow)
Enter fullscreen mode Exit fullscreen mode

This maps directly onto the tiered approach described in the source article (TEP for regulatory content, lighter MTPE-based workflows for high-volume descriptive content). The point of automating the routing is that nobody has to manually decide, SKU by SKU, whether a field is sensitive enough for a second linguist. You decide that once, at the schema level, and the pipeline enforces it.

Keeping terminology consistent at scale

Terminology drift is the real failure mode here, not bad grammar. If "recyclable packaging" gets translated three different ways across your catalogue, that's a compliance inconsistency waiting to be flagged.

If you're working with CAT tools or an LSP, make sure:

  • A termbase (TBX format works well) is maintained per product line, not per project
  • Translation memory (TMX) is reused across updates, not regenerated from scratch each release
  • Any machine translation step is constrained by the termbase, not run freely

If you want a lightweight internal check before content even reaches translation, a simple glossary validation script catches obvious drift:

import json

def validate_terminology(text, glossary):
    violations = []
    for term, approved in glossary.items():
        if term.lower() in text.lower() and approved.lower() not in text.lower():
            violations.append((term, approved))
    return violations

glossary = json.load(open("product_line_glossary.json"))
violations = validate_terminology(source_text, glossary)
Enter fullscreen mode Exit fullscreen mode

This won't replace a human reviewer on regulatory content, but it catches obvious inconsistency before it ever reaches a translator, which saves review cycles.

Keeping the QR code endpoint in sync

The DPP has to be live and queryable, which means your translated content needs a versioning strategy, not just a one-time push. A few practical points:

  • Version every field, not just the document. If a certificate gets re-issued, you need to know which language versions are stale.
  • Treat the QR endpoint as an API, with locale as a query parameter or path segment (/dpp/SKU-48213/en, /dpp/SKU-48213/de), not a static generated file per language.
  • Add a last_verified timestamp per language version, separate from last_updated on the source, so you can flag when a translation is lagging behind a source change.
{
  "product_id": "SKU-48213",
  "lang": "de",
  "source_updated": "2025-03-10",
  "translation_updated": "2025-03-09",
  "status": "stale"
}
Enter fullscreen mode Exit fullscreen mode

That status field is cheap to compute and extremely useful operationally: it's your early warning system for compliance drift across markets.

Where this leaves you

None of this replaces having a qualified linguist review your declarations of conformity, that part is non-negotiable and well covered in the source article. But the engineering work around it, tagging risk level, routing content, versioning translations against source changes, catching terminology drift before it reaches a human reviewer, is what determines whether this scales to a few thousand SKUs across a dozen EU markets or collapses into a spreadsheet nobody trusts.

If you're building this now, start with the schema. Everything else (routing, versioning, glossary checks) falls out naturally once risk level and translation status are first-class fields in your product data, not an afterthought bolted on at export time.

Top comments (0)