The problem with treating regulatory translation as a text file
If you've ever been pulled into a medical device or pharma project because "we just need someone technical to help manage the documents," you know the pain. Regulatory submissions, like the ones manufacturers send to ANVISA when entering the Brazilian market, involve hundreds of pages across IFUs, clinical evaluation reports, labelling, GMP certificates and technical specifications. Multiple translators, multiple reviewers, multiple document versions, and zero tolerance for inconsistency.
A good breakdown of what ANVISA actually requires in these dossiers is covered in this article on medical device translation for ANVISA. This post is not about the regulatory side. It's about the tooling problem underneath it: how do you keep terminology consistent across a document set that's being translated and reviewed in parallel by different people, often over months, without everything quietly drifting out of sync?
This happens constantly in software localization too, just with lower stakes. The same engineering patterns apply.
Why plain translation workflows break at scale
Send a PDF to a translator, get a PDF back, repeat for the next document. This works for one document. It falls apart at document 15 when:
- The IFU calls a part a "pressure sensor" and the clinical report calls it a "pressure transducer"
- Two translators working on different files pick different equivalents for the same regulatory term
- A term gets corrected in review on document 3 but nobody propagates that fix back to documents already translated
None of this is a translation quality problem in the traditional sense. It's a state management problem. You have a shared vocabulary that needs to be the single source of truth across N documents, M translators, and however many review cycles, and there's no git-like mechanism enforcing that by default.
Treat your glossary like a schema, not a spreadsheet
The fix that scales is the same one you'd reach for in any system with shared state: a single canonical source, validated programmatically, versioned, and fed into every downstream process.
1. Model the glossary as structured data, not a spreadsheet tab
{
"term_id": "PRESSURE_SENSOR_01",
"source_term": "pressure sensor",
"source_lang": "en",
"target_lang": "pt-BR",
"approved_translation": "sensor de pressão",
"forbidden_variants": ["transdutor de pressão"],
"regulatory_reference": "RDC 751/2022",
"device_class": ["III", "IV"],
"status": "approved",
"last_reviewed": "2024-11-02"
}
This is trivial to validate, diff, and query. A spreadsheet is not.
2. Lint translated documents against the glossary before they go anywhere near a human reviewer
import re
import json
def load_glossary(path):
with open(path) as f:
return json.load(f)
def check_forbidden_terms(text, glossary):
violations = []
for entry in glossary:
for variant in entry.get("forbidden_variants", []):
if re.search(re.escape(variant), text, re.IGNORECASE):
violations.append({
"found": variant,
"expected": entry["approved_translation"],
"term_id": entry["term_id"]
})
return violations
glossary = load_glossary("anvisa_glossary_pt-BR.json")
document_text = open("ifu_draft_pt-BR.txt").read()
violations = check_forbidden_terms(document_text, glossary)
for v in violations:
print(f"Inconsistent term: '{v['found']}' should be '{v['expected']}' ({v['term_id']})")
This is a five-minute script and it catches exactly the kind of inconsistency that triggers an ANVISA technical query. Run it as a CI step on every document before it's marked ready for review.
3. Wire it into whatever CAT tool or TMS you're already using
Tools like memoQ, Phrase, and Trados all support glossary import via TBX or CSV and most expose an API. If your pipeline touches any of these, don't rely on translators manually checking a reference doc. Push the glossary into the tool so terminology gets flagged inline during translation, not after.
A minimal integration with Phrase's API looks like this:
import requests
API_TOKEN = "your_token"
PROJECT_ID = "your_project_id"
headers = {"Authorization": f"token {API_TOKEN}"}
response = requests.post(
f"https://api.phrase.com/v2/projects/{PROJECT_ID}/glossary_terms",
headers=headers,
json={
"term": "pressure sensor",
"target_term": "sensor de pressão",
"locale_id": "pt-BR"
}
)
print(response.status_code, response.json())
Once terms live in the TMS, every translator sees the same approved equivalents in real time, and you get a central place to update a term once and have it apply everywhere it's referenced.
Version control for terminology decisions
Treat your glossary file like code. Put it in a git repo. Every change to an approved term is a pull request, reviewed by whoever owns regulatory terminology on the team (often a medical writer or regulatory affairs specialist, not an engineer). You get:
- A commit history of why a term changed and when
- The ability to pin a glossary version to a specific submission, so you know exactly which terminology set was used for the dossier submitted in March versus the one resubmitted in July after a query
- Easy diffing when regulations update and terminology needs to shift (RDC updates happen and old approved terms can become outdated)
git log --follow -- anvisa_glossary_pt-BR.json
git diff v1.2.0 v1.3.0 -- anvisa_glossary_pt-BR.json
This sounds obvious to anyone who writes software for a living. It is not obvious in regulatory affairs departments still managing terminology in shared Word documents, which is most of them.
Where to draw the line with automation
None of this replaces qualified medical translators or the kind of audited, ISO 17100 workflow that submission-grade documentation actually requires. Machine translation and automated linting will not catch a clinically meaningful mistranslation in a patient-facing IFU, and they should never be the final checkpoint before submission.
What this pipeline does is remove the boring, mechanical failure mode, inconsistent terminology across a large document set, so that human reviewers spend their time on the things that actually require clinical and regulatory judgment, not on catching a vocabulary mismatch a script could have flagged in milliseconds.
If you're the engineer who got pulled into a regulatory submission project because someone needed "the technical person," this is the lever worth pulling first.
Top comments (0)