DEV Community

Cover image for Building a Multilingual Documentation Pipeline for Regulated Hardware (Lift/Elevator Case Study)
Diogo Heleno
Diogo Heleno

Posted on Originally published at m21global.com

Building a Multilingual Documentation Pipeline for Regulated Hardware (Lift/Elevator Case Study)

If you've ever worked on tooling for a manufacturing or industrial company, you've probably run into the same wall: compliance documentation isn't just "content" that gets translated once and forgotten. It's versioned, legally binding, tightly coupled to terminology, and tied to certification processes that don't forgive inconsistency.

A recent piece on the M21Global blog walks through the legal side of this for lift (elevator) manufacturers under EU Directive 2014/33/EU — basically, if you place a lift on the market in an EU country, your operating instructions, maintenance manuals, and declaration of conformity have to be in that country's required language(s), or the product can't legally go to market.

That's the legal framing. What I want to cover here is the engineering problem behind it: how do you actually build a documentation pipeline that keeps terminology, formatting, and version control consistent across a dozen languages and an unknown number of future product revisions, without turning your technical writers into full-time translation project managers?

The core problem: documentation as a compliance artifact, not just content

Most CMS or docs-as-code setups treat translation as a content problem: extract strings, send to a vendor or API, get strings back, rebuild. That works fine for marketing copy or UI strings. It breaks down for regulated technical docs because:

  • Terms like "safety component," "overspeed governor," or "landing door locking device" have precise normative meaning tied to standards (EN 81 in this case). A generic MT engine or an unspecialized translator can produce something grammatically fine but technically wrong.
  • Documents are cross-referenced. A maintenance manual references section numbers, diagrams, and standard clauses. If translation tooling reflows or renumbers content, those references break silently.
  • The declaration of conformity is a legal document, not marketing copy. An inconsistency here isn't a typo, it's a compliance gap a notified body can flag.

This means your pipeline needs to treat terminology and structure as first-class, versioned data, not just translated prose.

Treat your glossary like a schema, not a wiki page

The single highest-leverage thing you can do is centralize terminology before anything goes to translation. In practice this means maintaining a structured termbase, not a shared doc.

A minimal termbase as structured data might look like this:

# termbase/lift-components.yml
- term_id: SAFETY_COMPONENT
  en: "safety component"
  es: "componente de seguridad"
  fr: "composant de sécurité"
  standard_ref: "EN 81-20 §5.1"
  do_not_translate_as:
    es: ["pieza no certificada"]

- term_id: OVERSPEED_GOVERNOR
  en: "overspeed governor"
  es: "limitador de velocidad"
  fr: "limiteur de vitesse"
  standard_ref: "EN 81-20 §5.6.2"
Enter fullscreen mode Exit fullscreen mode

If you're using a CAT tool (SDL Trados, memoQ, Phrase/Memsource) or a translation management system, most support importing TBX (TermBase eXchange) format. You can generate TBX programmatically from a source like the YAML above, which keeps your termbase in version control alongside the product documentation it describes.

import yaml
from lxml import etree

def build_tbx(yaml_path, out_path):
    with open(yaml_path) as f:
        terms = yaml.safe_load(f)

    tbx = etree.Element("tbx")
    body = etree.SubElement(tbx, "body")

    for term in terms:
        entry = etree.SubElement(body, "termEntry", id=term["term_id"])
        for lang in ("en", "es", "fr"):
            if lang in term:
                langset = etree.SubElement(entry, "langSet", lang=lang)
                tig = etree.SubElement(langset, "tig")
                etree.SubElement(tig, "term").text = term[lang]

    etree.ElementTree(tbx).write(out_path, pretty_print=True)
Enter fullscreen mode Exit fullscreen mode

This gives you a single source of truth that both your engineering team and any translation vendor can consume, and it's diffable in pull requests when a term changes.

Keep structure and translation separate

The formatting fragility mentioned in the source article (diagrams, section numbering, cross-references to standards) is really a separation-of-concerns problem. If your docs are authored in something like DITA, AsciiDoc, or Markdown with structured metadata, you can isolate translatable strings from structural elements.

A simple pattern: author in a structured format where cross-references are IDs, not hardcoded numbers.

=== Maintenance Procedure: Overspeed Governor Inspection

Refer to <<safety-component-table>> for certified component list.

[id=safety-component-table]
.Certified Safety Components
|===
| Component | Standard Ref
| Overspeed Governor | EN 81-20 §5.6.2
|===
Enter fullscreen mode Exit fullscreen mode

Because the reference is <<safety-component-table>> and not "see Table 4," renumbering during translation (where sentence length and layout change) doesn't break the link. This is a small thing, but it's the difference between a translated manual that still works in the field and one where a technician is told to check a table that moved three pages over.

Automating the handoff without losing QA

A practical pipeline for this kind of project usually looks like:

  1. Extraction: pull translatable segments from source docs (XLIFF is the standard interchange format most CAT tools and TMS platforms accept).
  2. Termbase + translation memory injection: feed your TBX glossary and any existing translation memory (TMX) into the TMS so repeated terms across manuals stay consistent.
  3. Human translation + QA pass: for regulated technical content, skip pure MT. You want a translator with domain background, plus an editor and a QA reviewer checking against the termbase — which is effectively what certification schemes like ISO 17100 formalize into a workflow (translator, editor, reviewer, each independently qualified).
  4. Re-import and structural validation: after translation, run an automated check that cross-reference IDs, table counts, and figure numbers still resolve correctly before anything goes to the printer or gets bundled into a CE technical file.

A basic structural validation script for step 4:

import re

def validate_refs(source_path, translated_path):
    def extract_ids(path):
        with open(path) as f:
            text = f.read()
        defined = set(re.findall(r"\[id=([\w-]+)\]", text))
        referenced = set(re.findall(r"<<([\w-]+)>>", text))
        return defined, referenced

    src_defined, src_ref = extract_ids(source_path)
    tgt_defined, tgt_ref = extract_ids(translated_path)

    missing = tgt_ref - tgt_defined
    if missing:
        raise ValueError(f"Broken refs in translation: {missing}")
    if src_defined != tgt_defined:
        print(f"Warning: id mismatch. Source: {src_defined}, Target: {tgt_defined}")
Enter fullscreen mode Exit fullscreen mode

Run this in CI on every translated doc before it's marked ready for the certification package. It won't catch a mistranslated technical term, but it will catch the structural breakage that turns a correct translation into a dangerous one.

Where this fits with your vendor or TMS choice

If you're evaluating translation vendors for this kind of work, ask specifically:

  • Do they support TBX/TMX import so your termbase and memory carry across projects and languages?
  • Can they commit to a fixed glossary for model-specific component names across all documents for that product line?
  • What's their QA workflow — is it a single translator, or translator + editor + independent reviewer?

The source article covers the regulatory side of this (which languages are legally required, what counts as part of the conformity assessment) in more detail — worth reading if you're the one responsible for the certification file, not just the docs pipeline.

None of this is unique to lifts. The same approach applies to any regulated hardware: medical devices, industrial machinery, pressure equipment. The common thread is that translation stops being a content task and becomes a data consistency problem the moment a mistranslated term can trigger a safety incident or a failed audit.

Top comments (0)