Your translation team just landed a 500-page contract to localize a SaaS platform for 8 markets. Deadline: 6 weeks. Budget: tight. The math doesn’t work without automation—but full machine translation alone will come back with awkward phrasing and missed terminology. You need human eyes + machine speed. That’s where integrating machine translation into your CAT (Computer-Aided Translation) tool pipeline becomes essential.
This guide walks you through connecting MT engines to your workflow, choosing the right approach for your team’s size and content type, and measuring whether it’s actually working.
What You’re Actually Doing When You “Integrate MT”¶
When we say “integrate MT into a CAT tool,” we don’t mean replacing translators with robots. We mean: your CAT tool (Trados, memoQ, Phrase, Smartcat, XTM, or similar) connects to a machine translation engine—Google Translate, DeepL, Microsoft Translator, Language Weaver, or a custom model—and displays MT suggestions alongside translation memory matches and terminology hits in the same interface.
A translator sees:
- Source segment
- 100% match from translation memory (if available)
- Fuzzy TM matches (75-99%)
- MT suggestion
- Terminology database entries
- Their own previous work on similar segments
The translator picks the best starting point (often TM first, then MT if TM is cold), edits it, and confirms. The CAT tool logs that edit, feeds it back to the TM, and learns from the correction for next time. Speed: not from skipping translation—from starting with a 70-80% correct draft instead of a blank page.
That’s Machine Translation Post-Editing (MTPE), and it’s how most professional agencies scale.
How Much Faster Are We Talking?¶
Real numbers from teams running live MTPE workflows:
Light Post-Editing (fixing grammar, obvious errors, segment-level mistranslations; keeping MT structure): 2-3x word-per-hour throughput vs traditional translation. A translator doing 250 words/hour in pure human translation might hit 600-800 words/hour in light MTPE. Trade-off: lower quality, suitable for high-volume, low-risk content (technical documentation, software strings, support FAQs).
Full Post-Editing (ensuring output matches human-translation standards for tone, style, cultural appropriateness, readability): 15-30% productivity lift vs pure human translation. Same 250-word/hour translator reaches 280-325 words/hour. Higher quality, suitable for marketing, legal, public-facing materials.
Why the gap? Light MTPE treats MT as a rough draft; full MTPE means re-translating substantial portions—you’re not really saving as much time, but you’re still faster than starting from zero because terminology and proper names are often correct in the MT output.
Pairing MT with a solid translation memory: Zero-edit rates (segments MT or TM handles perfectly without human changes) jump to 30-50% for professional MT engines, vs 5-20% for cloud-only Google Translate without TM context.
Three Integration Paths—Pick Your Trade-Off¶
Path 1: Built-In Connectors (Simplest, Least Flexible)¶
Your CAT tool already has MT options baked in. Open settings → MT Providers → enable DeepL or Google → done.
Setup time: 15 minutes.
MT providers available: Trados connects to Language Weaver (RWS proprietary), DeepL, Google, Microsoft Translator. MemoQ supports Google, Microsoft, DeepL, ChatGPT. Phrase includes DeepL, Google, AWS, custom. Smartcat has its own adaptive MT + third-party connectors.
Control you get: Zero. You feed text to the engine, get output back. No training, no custom terminology injection, no domain specialization. The MT engine runs on its default model.
Cost: Usually free or included in your CAT tool subscription; or metered MT charges from the provider (DeepL ~$15-20 per million characters, for example).
When to use: Quick pilots, low-stakes content, language pairs where generic MT is good enough.
Gotcha: Output quality is generic. If your domain has specialized terminology or tone (legal, medical, marketing), generic MT stumbles.
Path 2: API Integration via Plugins (Flexible, Requires Moderate Setup)¶
Your CAT tool vendor provides a plugin that connects to an MT API. You configure authentication, API keys, and parameters—then the CAT tool talks to the MT service directly, with more control.
Setup time: 2-5 days. Involves: getting API credentials, configuring in the CAT tool, testing on sample content, training your team on the new interface.
MT providers: Any provider with a public API (DeepL API, Google Cloud Translate, Microsoft Translator, AWS Translate, Azure Cognitive Services, Language Weaver API, Custom.MT, or open-source options like Argos, LibreTranslate).
Control you get: More. You can specify: - Language pair - Formality level (for some engines) - Custom terminology (if the API supports it) - Priority/speed/cost trade-offs
Some APIs support domain-specific pre-training models—you feed them parallel data (your old translations) and they refine the base engine.
Cost: API charges per million characters. DeepL API ~$15-20/million. Google Cloud Translate ~$15-25/million (depending on API tier). Custom pre-trained engines: $500-3000+ per month depending on volume and vendor.
When to use: Scaling teams (10+ translators), consistent content, and you want quality tuning. Agencies managing multiple client TM’s often use this.
Gotcha: Requires IT coordination if you’re on-premise CAT tool. Cloud CAT tools (Smartcat, Phrase, Crowdin) handle this smoother.
Path 3: Custom Domain-Specific MT Engine (Best Quality, Most Expensive)¶
You train your own Neural Machine Translation (NMT) engine on your historical translations. Feed the engine 50,000+ parallel segments (source + target pairs from your translation memory), and it learns your terminology, style, and domain patterns. Then plug it into your CAT tool via API.
Setup time: 3-8 weeks. Involves: collecting and cleaning your TM data, selecting an NMT platform (Unbabel Tower, Custom.MT, Language Weaver Advanced Customization, or open-source Marian/OpenNMT if you have in-house ML), training the model, testing, integrating.
MT providers: Unbabel (Tower), Custom.MT (integrates Claude/Lara/Widn LLMs), RWS (Language Weaver Custom), Amazon Translate Custom Terminology, open-source Marian, OpenNMT.
Control you get: Maximum. The model learns your exact vocabulary, phrasing patterns, and tone. For niche domains (law, pharma, fintech), custom MT can achieve 50-70% zero-edit rates before human review.
Cost: $2,000-10,000+ setup; $500-2,000/month for hosting and updates. Requires content volume to justify (minimum ~100,000 words of proprietary TM).
When to use: Agencies processing 500K+ words/month in a specialized domain; enterprise translation departments.
Gotcha: Needs good historical data. If your old TM is messy, inconsistent, or full of errors, the custom engine learns bad patterns. Plan 2-3 weeks for TM cleanup before training.
Step-by-Step: Setting Up MT Integration¶
Let’s walk through Path 2 (most common for growing teams) using memoQ as an example. The process is similar in Trados, Phrase, and Smartcat.
Step 1: Choose Your MT Engine and Get Credentials¶
Pick one: DeepL (best general quality), Google Translate (broadest languages), Microsoft Translator (if you’re in Azure ecosystem), or a domain-specific engine.
Example: DeepL API
- Go to deeplapi.com, sign up for a free tier (500,000 characters/month) or paid ($10/month base + usage).
- Get your API key (a long string like sk-2f23f923f923f).
- Copy it—you’ll paste it into memoQ next.
Step 2: Configure in Your CAT Tool¶
In memoQ: - Tools → Options → Machine Translation. - Add MT server: select “Custom Web Service” or choose “DeepL” if memoQ has a native plugin. - Paste your API key. - Select source/target language pairs you want to enable. - Test: create a test project, open a segment, see if MT suggestion appears in the MT panel.
In Trados: - Project Settings → Machine Translation. - Select provider (Language Weaver, Google, Microsoft, or custom). - Authenticate and select language pairs.
Step 3: Build a Terminology Database (Critical—This Is 40% of Quality Improvement)¶
MT engines guess on terminology. If your product has a unique term (e.g., “tokenomics” for crypto, “modular architecture” for SaaS), generic MT might mistranslate it. Terminology databases override MT’s guess.
In your CAT tool, create a glossary with: - Source term → Target translation - Part of speech (noun, verb, adjective) - Example in context - Do not translate (e.g., brand names, acronyms)
Example for a SaaS translation (English → German):
| EN Term | DE Term | Type | Example | Don’t Translate? |
|---|---|---|---|---|
| API | API | noun | The API returns JSON | Yes |
| workflow | Arbeitsablauf | noun | Streamline your workflow | No |
| dashboard | Dashboard | noun | View metrics on the dashboard | Yes |
| onboard | Onboarding durchführen | verb | We help you onboard users | No |
Build this with your SMEs (subject matter experts) before launch. Update monthly as product terminology evolves. Even a 200-entry glossary lifts MT quality 30-40% because it locks in consistent terminology.
Step 4: Define Post-Editing Guidelines¶
Tell your team exactly what “good enough” means for MT output:
Light Post-Editing Guidelines (2-3x speed, used for technical docs): - Fix obvious grammar errors (missing article, wrong tense). - Correct segment-level mistranslations (wrong word order, swapped meaning). - Do NOT rewrite for style or flow—keep MT phrasing if it’s grammatically correct. - Edit distance target: 10-20% of segment words changed.
Full Post-Editing Guidelines (15-30% speed, used for marketing/legal): - Fix all grammar and terminology (glossary entries must be exact). - Ensure tone/register matches the original (formal for legal, friendly for marketing). - Rewrite phrasing if MT is clumsy but technically correct. - Add context/cultural references if MT misses nuance. - Edit distance target: 30-50% of segment words changed.
Share these in your CAT tool workspace and review them weekly in kickoff meetings. Inconsistent guidelines = variable quality and wasted edits.
Step 5: Pilot with One Project, One Language Pair, One Post-Editor¶
Don’t flip the switch for 200K words across 5 languages tomorrow. Start small.
- Pick one project: 5,000-10,000 words.
- Pick one language pair: your strongest translator’s pair.
- Run it for 1-2 weeks with MT on.
- Measure: words per hour, zero-edit rate, error rate (spot-check 100 segments for correctness).
- Compare to baseline (same translator, same content, no MT).
Example metrics to track:
| Metric | Without MT | With MT (Light MTPE) | With MT (Full MTPE) |
|---|---|---|---|
| Words/hour | 250 | 700 | 300 |
| Zero-edit rate (%) | — | 25% | 5% |
| Error rate (per 100 words) | 1-2 | 3-5 | 0.5-1 |
| Revision rounds | 1 (internal review) | 0.5 (less rework) | 1 (quality check) |
Step 6: Train Your Team¶
Even a 15-minute training cuts errors 30%. Teach: - Where to find MT suggestions in the interface. - How to accept/reject/edit them (keyboard shortcuts—muscle memory matters). - Your post-editing guidelines (light vs full, what counts as “done”). - When to use terminology database lookup to override MT. - Fatigue patterns (post-editing is monotonous; take breaks to stay sharp).
Pro tip: Play back recorded edits. Show your team what good light MTPE looks like vs over-editing. Most teams over-edit at first, wasting time.
Step 7: Monitor and Iterate¶
After 2-4 weeks: - Collect team feedback (is MT slowing them down? Is it reliable for this domain?). - Check error rates (spotlight QA on 100 segments, calculate true error count). - Recalibrate terminology if certain terms keep appearing wrong. - Switch MT engines or adjust settings if needed.
Monthly, measure: cost per word, productivity trends, and whether MT is actually cutting your costs or just moving work around.
Common Pitfalls (and How to Avoid Them)¶
Pitfall 1: Launching MT without updating your terminology database.
MT + empty glossary = garbage in, garbage out. Spend a week building glossary. Skip this and quality tanks; team turns off MT in week 2.
Fix: Require glossary with 100+ core terms before you go live with MT.
Pitfall 2: Mixing light and full MTPE guidelines.
Translators aren’t sure how deep to edit. Some do light (fast, shallow), others do full (slow, deep). Output is inconsistent, some content needs rework.
Fix: Pick one per project. Make it explicit in project settings and kickoff.
Pitfall 3: Bad source text garbage-in, garbage-out machine translation.
Your source English is poorly written (inconsistent terminology, grammatical errors, unclear instructions). MT amplifies those errors. Post-editors spend 40% of time guessing what the source meant instead of translating.
Fix: Implement source text QA before MT. Simple grammar check + terminology check on the source. Most translation platforms (Phrase, Smartcat) have this built in.
Pitfall 4: Not measuring before you claim success.
You implement MT, team says it feels faster, you assume it’s working. Then you check the numbers and cost per word went up because everyone’s editing more.
Fix: Set baseline metrics (words/hour, zero-edit rate, cost) before you enable MT. Measure again after 2 weeks and 8 weeks. Only compare like-for-like projects.
Pitfall 5: Expecting MT to work for low-resource language pairs.
MT for EN→DE or EN→FR is solid (lots of training data). MT for EN→Belarusian or EN→Hausa is rough. If you force MTPE on low-resource pairs, post-editors spend more time fixing MT than translating fresh.
Fix: Test MT on your language pairs first. If zero-edit rate is under 5-10%, skip MT for that pair. Use MT only on language pairs where you see 20%+ zero-edit.
How to Measure ROI (Does MT Actually Pay Off?)¶
After 4 weeks of MT integration, calculate:
Cost per word before MT: (Translator hourly rate ÷ 250 words/hour) = cost/word
Example: $40/hour ÷ 250 = $0.16/word
Cost per word with MT: (Translator rate ÷ words/hour with MT) = cost/word
Example: $40/hour ÷ 700 (light MTPE) = $0.057/word
MT overhead: API charges + glossary maintenance (~2 hours/month) + QA overhead.
Example: DeepL API $100/month + 2 hours glossary work (at $40/hr = $80) = ~$180/month. On 500K words/month: $0.00036/word.
True cost reduction: ($0.16 - $0.057 - $0.00036) ÷ $0.16 = 64% cost reduction
Most agencies see 20-40% net cost reduction in the first 3 months. The longer the engagement, the better—older translation memories give MT more 100% matches, pushing productivity higher.
When NOT to Use MT (And What to Do Instead)¶
- Highly stylized or creative content (poetry, brand campaigns, literary translation): Human translation + CAT tool + TM only, no MT. MT can’t capture tone.
- Regulated content with audit requirements (medical, legal, certified translations): Human translation required; MT is option for early draft only, not for final output.
- Language pairs with poor MT (low-resource languages, extremely different writing systems): Skip MT. Go with human + TM + terminology.
- One-off, short projects (a single 500-word document): Setup time outweighs benefit. Just translate manually.
FAQ¶
Q: Do we need to license separate MT, or does our CAT tool include it?
A: Your CAT tool usually offers free connectivity to free/freemium MT services (Google Translate, limited DeepL). Paid MT APIs charge separately. Most teams spend $100-500/month on MT if they’re doing 500K+ words/month. Budget accordingly.
Q: Can we switch MT engines mid-project?
A: Yes. Turn off the old engine, turn on the new one. Segments already post-edited stay as-is; new segments get suggestions from the new engine. No data loss.
Q: What if our post-editors just accept all MT without reviewing?
A: This happens, especially under deadline pressure. Fix it with: (1) quality spot-checks (review 5-10% of post-edited segments, flag errors back to post-editor), (2) peer review (rotate who reviews whom), (3) LQA metrics (language quality assurance—automated checks for grammar, terminology, punctuation). Most CAT tools have built-in QA.
Q: Does machine translation replace human translators?
A: No. It augments them. A translator + MT + TM system is faster than a translator alone, but the translator still makes every final decision. MTPE is a translator job, not a robot job.
Machine translation integration isn’t a “set it and forget it” setup. It’s a workflow change—new tools, new guidelines, new QA. The teams that see real ROI are those that invest in terminology, train their post-editors well, and measure outcomes. Start small, measure, iterate, and scale.
Your 500-page, 8-market project becomes doable when 40-50% of segments come pre-translated (via TM or MT) and your team focuses on polishing, not starting from zero.