The problem with conventional machine translation post-editing (MTPE)

Training a conventional MT engine for high-quality output requires a significant up-front investment of engineering resources and time. Consequently, few boutique LSPs can actually afford to provide properly trained MT to their linguists. Instead, they are forced to plug into rigid, off-the-shelf engines and automated workflows designed by and for mega-agencies.

The burden is then shifted entirely onto the post-editing phase, forcing the linguist to fix deeply rooted problems caused by poor source-text preparation and inherent engine inadequacies.

“Translators are routinely forced to battle incorrect terminology, erratic style, and inconsistent punctuation. It is an exhausting, morale-killing grind that breeds resentment.”

Steven S. Bammel, PhD
Workflow Methodologist & Architect

Human and business cost

The reality is often even worse when dealing with complex files. Converting PDFs to Word documents introduces broken segmentation, “tag soup,” and OCR errors. When these formatting glitches collide with a standard MT engine in a poorly prepared source file, they trigger broken translations and uncontrollable, document-wide inconsistencies.

This leaves the translator trapped in a tedious cycle of retranslating useless MT, aligning all-over-the-place terminology, and manually fixing basic formatting—over and over again, from the beginning of the project to the end—all at reduced post-editing rates.

Ultimately, this friction leads to lower-quality client deliverables, which inadvertently drives clients to take their work to free AI tools that offer the exact same mediocrity at zero cost.

A premium workflow with GAIT-Augmented MT & MTPE

Now, consider a completely different paradigm.

• Imagine a scenario where the translator never has to wrestle with tag soup or fix mechanical errors caused by careless file preparation.

• Imagine a workflow where the baseline AI-generated machine translation is already highly readable, cohesive, and contextually accurate right out of the gate.

• Imagine a dynamic process where the translator’s initial edits actively train the AI prompt, yielding more aligned, superior output for the remainder of the project.

Achieving this does not require high-priced enterprise systems and processes. It simply demands the right workflow.

By stripping away structural and mechanical friction right from the start, the translator finally gains the mental bandwidth to focus on strategic editing—delivering true excellence at an efficient pace that keeps everyone profitable. The GAIT-Augmented MT & MTPE workflow is engineered to deliver exactly this.

Step 1 – Clean and prep source files

Word files converted from PDFs often contain hundreds or thousands of unnecessary tags when imported directly into a CAT tool. While many of these can technically be ignored, forcing a translator to wade through them to separate the necessary from the unnecessary creates severe cognitive friction.

Worse yet, this “tag soup” introduces two more problems to the workflow:

• Coherency: Excessive tags interrupt the AI’s ability to process the text contextually, frequently triggering broken or incorrect translations.

• Inconsistency: Random tag placement hides identical segments from the CAT tool’s analysis, misclassifying them as internal “fuzzy matches.” If these hidden duplicates are not isolated through additional manual processes, they lead to uncontrollable inconsistencies across the final translation.

To eliminate this friction before translation even begins, I execute customized profiles in TransTools and TransTools+, alongside my own custom macros. This process strips out the random font variations that cause excessive tagging and corrects other critical source file deficiencies, including: excessive or erratic spacing, incorrect quotation marks, hard line breaks, and OCR-related text variations.

By thoroughly prepping the source files up front, I minimize tags to reduce the workload in later steps.

Step 2 – Import into the CAT-tool environment

In theory, the GAIT-Augmented MT & MTPE workflow is compatible with any advanced CAT tool. However, I have meticulously fine-tuned my processes for memoQ translator pro, running everything through my local installation. This setup allows me to process any file format compatible with memoQ, including packages from other CAT tools.

Through deep technical know-how and strict attention to detail, I configure my file imports specifically to minimize billable word counts and maximize duplicate matching. To achieve the leanest, most efficient translation environment possible, I disable or omit non-essential overhead during import, including TM context matching, version tracking, preview creation, embedded objects, and alternative image text.

Step 3 – Inspect and optimize segmentation

To further maximize duplicate and internal fuzzy matching—and to provide both the AI and the translator with the cleanest possible file—I review the document segment by segment to ensure every line consists of a single, complete unit. This meticulous preparation phase relies on a disciplined, three-pronged approach:

• Segment consolidation: Joining broken segment fragments back into cohesive, full segments

• Strategic segmentation: Splitting multi-unit blocks into single-unit parts to improve translation memory matching

• Isolation of non-translatables: Splitting off excessive tags, standalone numbers, and various symbols from the main text

Further, in files with complex formatting—especially Word documents converted from PDFs—a single sentence is sometimes split into fragments and separated by completely unrelated text in the CAT tool import. Using my own technique, I dynamically stitch these disjointed pieces back together for the translator without compromising the underlying file architecture, restoring them to their original layout positions during the final formatting stage. While this alignment is time-consuming, it represents another differentiator that directly protects final translation quality.

Step 4 – Lock out non-target segments

1. Repetition isolation

I lock out all secondary and subsequent repetitions, leaving only the very first instance unlocked in the text for post-editing. While rare exceptions exist where a duplicate word or phrase requires a different translation based on context, this is unusual within a single document or project.

Conversely, leaving repetitions unlocked but editable in the work file creates unnecessary cognitive friction for the linguist, who is unlikely to inspect each one individually anyway. This is especially true because most MTPE clients offer zero payment for repetitions—even if they fail to lock them out during their own file prep. My approach eliminates this uncompensated cognitive load up front.

2. Non-translatables exclusion

Next, I systematically isolate and lock out all purely mechanical elements that do not require human linguistic intervention, such as standalone numbers, symbols, and isolated tags.

3. Advanced internal fuzzy and near-duplicate removal

The final and most labor-intensive phase tackles internal fuzzy matches and hidden near-duplicates. This includes segments that are linguistically identical but structurally mismatched due to:

• Formatting differences (e.g., a word bolded in one segment but plain in another)

• Asymmetrical segmentation (corrected in my previous step, but with an added tag to indicate the separation)

• Discrepant tag configurations

• OCR-induced text variations

• Identical text variations with easily automatable updates (such as shifting serial or large numbers)

I generally lock these out manually by alphabetizing the source text and evaluating them line by line. For files with high remaining homogeneity (a dense volume of internal fuzzies), I deploy an advanced alignment technique that hunts down and reconciles masked segments missed during the first pass. While this is a particularly time-consuming process, these segments remain locked out of the post-editing workflow to be populated and updated later based on the master text, maximizing total consistency.

The savings, scheduling, and quality impact

This rigorous filtration directly shrinks the post-editing scope, yielding savings in both translation fees and project turnaround times, while driving up final quality.

On a recent 130,000-word project, the compounding impact of this methodology was clear:

• Standard duplicate removal: Dropped the initial count from 130,000 to 93,000 words (a CAT-leveraged savings passed directly to my LSP client).

• Advanced clean-up: Systematically removing the remaining non-translatables and hidden internal fuzzies slashed the final post-editing scope down to just 69,000 words.

By stripping an additional 24,000 words completely out of the post-editing workflow, the client enjoyed a compressed timeline and a significantly lower invoice from the post-editor. I include an incentive-based billing line item on these projects to mutually share the rewards of these savings with my LSP client.

Crucially, this volume reduction doubles as a quality advantage, too. Generative AI workflows are inherently better at following complex stylistic instructions and maintaining internal consistency when they can process text within fewer, more concentrated context windows. By consolidating the core text and propagating the fuzzy matches from a single, verified baseline later, the entire document achieves a level of cohesive quality that standard, cluttered MTPE workflows cannot match.

Step 5 – Leverage existing translation memories

I now begin integrating existing project assets (if any) by pre-translating the remaining unlocked segments using the client’s translation memory.

Even when working with a target language I don’t understand, my technical familiarity with file and text architecture allows me to confidently confirm certain high-level matches:

• 100% matches: Automatically locked and confirmed

• 95–99% fuzzy matches: Manually evaluated and confirmed, as these minor deltas are usually caused by mechanical formatting variations, tag differences, or shifting numerals

• Lower-level fuzzies: Identified and validated where the CAT tool misclassifies a true identical match due to surface-level discrepancies like punctuation (straight vs. smart quotes), spacing anomalies, minor OCR-recognition differences, or other causes.

By default, I leave these confirmed TM matches within the active post-editing scope to allow the linguist to review them in context. However, if my LSP client prefers to aggressively slash post-editing fees, I can lock these confirmed matches completely out of the active work scope as well, while still leaving them visible in the file for linguistic reference.

And there’s one more match type I lock out: remaining TM fuzzies of around 65-70% match and up. For now, I leave them untranslated and unconfirmed, but marked in the CAT tool as fuzzies so I can filter for them easily later. I will come back to them after machine translating all of the non-locked segments.

Because duplicates and internal fuzzies have already been isolated and locked out during the earlier steps, any contextual edits the post-editor makes to the active confirmed segments are automatically propagated through my follow-up processes to all corresponding segments. This introduces another quality upgrade over conventional workflows. Normally, when identical or near-identical segments appear throughout a document (or multiple documents), a linguist rarely remembers how they edited a specific iteration dozens or hundreds of segments prior and may not make the same edits in subsequent segments. This can flood the finalized TM with multiple, translation variations for the exact same source text—compromising the integrity of both the current document and the client’s master assets. By reducing the number of potential failure points, I promote much higher consistency across the text and prevent TM pollution.

I conclude this phase by completely clearing out all unconfirmed, low-level translations from the remaining unlocked segments, leaving only crisp, validated data for the AI engine.

Step 6 – Convert native formatting to inline tags

Because LLMs do not natively support text formatting, maintaining a document’s visual layout requires a workaround to prevent formatting loss. Fortunately, AI models handle inline tags exceptionally well—provided they are not overwhelmed by them. This means the AI can usually position inline formatting tags around the correct words and phrases in the target text, even when complex syntax changes from the source language to target language require switching the sentence order around.

To leverage this capability, I execute a specialized set of regular expressions (RegEx) within memoQ to convert all native formatting into inline tags. While this step inherently increases the immediate tag count, the system remains unburdened because the “tag soup” and mechanical noise were already eliminated during the earlier file preparation phases.

Once the formatting has been converted into these manageable inline elements, I can safely proceed with the AI translation process. This ensures that all structural layout information is preserved and easily restored to standard visible formatting once I get past the machine translation step.

Step 7 – Build the core project anchor prompt

Step 8 – Translate in context-aware blocks

Once the text has been completely prepped and the initial project anchor prompt is built, I begin the actual machine translation process. The golden rule at this stage is that I do not translate inside the CAT tool. Instead, I export the source text to a bilingual file and drive the translation from there.

The process is straightforward: I load the anchor prompt into my AI tool (CotranslatorAI), append a block of the source text to it, and send it to the AI. When the AI generates the target text, I paste it directly back into my bilingual file. This workflow is highly flexible. I can remain in the bilingual file until the entire job is finished, or I can continuously cycle between the file and the CAT tool—importing translations, manipulating the text, and exporting fresh bilingual files for subsequent untranslated segments.

Executing the translation this way unlocks four critical advantages:

• Full-context processing: Translating in blocks of multiple segments at once (usually 24 to 36 segments) gives the AI the broad context necessary for highly accurate, coherent translations. This cannot be done inside a CAT tool. Even AI-based CAT plugins that claim to translate entire documents at once actually process the text segment by segment on the backend, which compromises context and degrades quality.

• Intra-block consistency: Translating in blocks naturally compels the AI to translate every term consistently throughout that specific chunk of text in a single turn—a huge improvement over conventional MT engines.

• Flawless tag handling: Tags copied directly from a CAT tool interface fail to transfer to the AI as readable text. By routing the text through a bilingual Word file, the inline tags we created earlier are preserved, safeguarding formatting.

• Rapid execution: After investing so much effort into rigorous source text preparation, routing the translation through multi-segment blocks speeds up the process dramatically, providing a refreshing acceleration to the workflow.

Managing the context window (micro iteration)

The translation strategy does not stop simply at linear source-text block processing. Even with a perfectly prepared file and a bulletproof anchor prompt, we will inevitably introduce unwanted inconsistencies if we translate each block of text in its own context window.

To combat this, I use follow-up prompting (in CotranslatorAI we call it “ad-hoc prompting”). Instead of starting a new context window for the next block, I paste the next block of text as a follow-up prompt within the same AI dialogue. This keeps us inside the same context window, granting the AI access to previously translated blocks so it can naturally align the terminology and style of the new text with the previous text.

However, we cannot sustain a single context window forever. Eventually, the AI’s ability to efficiently process the core instructions, the growing prompt history, and the new text begins to degrade. In long documents, I must periodically clear the board and start over with a new AI dialogue.

This reset provides the perfect opportunity for micro iteration. When I restart the process, I actively update the anchor prompt to reflect the evolving project. If the document’s content has shifted, or if I need to add newly discovered words to the glossary, I apply advanced techniques to refine the anchor prompt before launching the next sequence.

By meticulously managing this cycle of block translation and context resets, I work my way through the document, continuously pushing the AI to the frontier of its translation capabilities.

Finally, once I finish translating all of the non-locked segments, I still have one step left. You will recall that I locked remaining fuzzy matches in Step 5 above, but left them marked as fuzzy matches in the CAT tool. I now go back and filter for those fuzzy matches and unlock them. I also pre-translate them on the spot and export them out to a bilingual file, with the fuzzy target text in the translation column. I then paste a special “fuzzy match translation add-on” to the project anchor prompt. This add-on is written so that when I copy and paste both the new source segment and the highest-value fuzzy match target segment in the translation column together into my translation tool (CotranslatorAI), it generates a new translation of the source text which matches the fuzzy match as closely as possible. This ensures once again consistency with the project TM and terminology, and do focus the AI’s attention as closely as possible on this task, I translate these fuzzy matches segment by segment, one after another.

Once I finish the fuzzy matches, the machine translation phase is complete. I import the finished bilingual file back into my CAT tool. This updates the project. I then confirm all unlocked segments and proceed to the next step.

Step 9 – Revert tags to native formatting

Now that the AI translation phase is complete and the populated bilingual file is safely back inside the CAT tool, the next step is to restore the document’s visual layout.

To achieve this, I simply reverse the earlier formatting workaround. Using a corresponding set of reverse regular expressions (RegEx) within memoQ, I transform the explicit inline tags back into standard, visible native formatting.

Because I carefully controlled the tag density and eliminated mechanical “tag soup” during the preparation phases, the AI was able to position these inline tags correctly around the corresponding translated words. As a result, when the reverse RegEx runs, the original layout elements—bold, italics, underline, subscript, and superscript—snap back into place, even in complex sentences where the target language required a completely different syntactic word order.

With the native formatting cleanly restored and the visual structure intact, the file is now highly readable and primed for the human post-editing and quality assurance phases.

Step 10 – Execute human post-editing

Once the AI translation and formatting restoration are complete, the project is ready for human post-editing. In standard MTPE workflows, this stage often creates friction, forcing highly skilled linguists to act as “janitors” cleaning up disjointed machine text and mechanical errors.

The GAIT-Augmented MT & MTPE workflow subverts this dynamic. By handing off a well-prepped, contextually fluent draft, we elevate the linguist to a strategic editor. For an LSP, this translates directly to faster turnaround times, higher final quality, and improved translator satisfaction.

Here is how this optimized handoff process delivers value to both the LSP and the post-editor:

• Platform agnosticism: To accommodate your specific operational needs and your linguists’ preferences, I can provide the files for post-editing in virtually any standard format: .xliff for their preferred CAT tool, bilingual Word files, or uploaded directly into your proprietary online TMS. I can even skip to the end of this workflow and simply export out the final machine-translated files so that the translator can post edit those.

• Zero mechanical friction: Because the files were rigorously prepped and stripped of “tag soup,” broken segments, and OCR error impact in earlier steps, the linguist is freed from tedious cleanup tasks. Their billable time and cognitive energy are spent on linguistic refinement.

• Eliminating the “Frankenstein Effect”: Standard MT engines process text segment-by-segment without being adapted to the project at hand. This creates a disjointed mix of TM hits and raw machine output. Because the GAIT-Augmented MT & MTPE workflow generates the translation in context-aware blocks driven by a single anchor prompt matched to a gold standard for the respective project, the linguist receives a cohesive, fluent draft in a unified voice.

• Dynamic quality loops: On large, multi-batch projects, we can run an iterative workflow. If a linguist identifies an overarching structural preference or new terminology in the first batch, I can reflect that feedback directly back into the anchor prompt, upgrading the baseline quality of subsequent batches.

• On-call linguist support: To ensure maximum efficiency and higher translator buy-in, I am even including direct, professional coaching for linguists new to this workflow as a complimentary part of my baseline service upon request. Many veteran translators are still working through this major paradigm shift, and if we do not actively help them adapt, you will not be able to work with your best linguists on a growing segment of your work. This certainly means more unbilled work for me behind the scenes, but if we don’t help our community step up to become strategic editors, who will?

To make sure this handoff fits into your existing operations, I offer highly flexible collaboration models during the post-editing stage. I can interface directly with the translators to provide guidance and gather iterative feedback, or I can route all communication strictly through your project managers—whichever approach best serves your team and your internal workflows.

Once the linguist has finalized the post-editing and quality checks, the completed files are routed back to me so I can convert the post-edited files into my deliverables to you.

Step 11 – Propagate edits and finalize segments

Once I receive the completed files back from the linguist, I import them into my CAT tool and officially confirm the post-edited segments. However, the structural work is not yet finished. The segments that were strategically locked out during the initial file preparation phase—such as duplicates, hidden internal fuzzies, and non-translatables—must now be reconciled against this newly vetted master text.

To ensure quality control, I execute a strict, cascading propagation process:

• TM isolation and purity: First, I isolate the newly post-edited segments into an active, working translation memory. If the project utilized legacy client TMs, I create a brand-new TM populated only with this freshly vetted post-edited output. This creates a firewall, ensuring that no unvetted or legacy segments accidentally overwrite our finalized translation.

• Exact match propagation: With the clean TM established, I unlock all previously locked segments and pre-translate for 100% exact matches. This updates all standard duplicates across the entire document using the linguist’s finalized translations, ensuring consistency throughout.

• High-fuzzy reconciliation (95–99%): Next, I pre-translate the high-level fuzzy matches. I review and confirm these one by one, utilizing auto-propagation to instantly update any internal repetitions tied to these specific segments.

• Masked match resolution: I then run a pre-translation pass for any remaining TM hits. This deliberately captures the hidden near-duplicates that registered artificially low fuzzy match scores due to earlier OCR discrepancies, tag variations, or other significant formatting differences.

• Non-translatable verification: Finally, I conduct a thorough sweep of the remaining non-translatable segments (numbers, isolated tags, symbols) to ensure that every element requiring translation has been addressed.

By strategically controlling how the human edits are populated back into the locked segments, this process guarantees that the highest standard of quality and consistency is pushed into every single corner of the final document.

Step 12 – Export and deliver final assets

With the translation integrated and verified, I export the translation back into the native, original format.

This is where the final structural puzzle pieces are put back into place. As mentioned during the initial file preparation phase, complex documents—especially Word files converted from PDFs—sometimes contain fragmented sentences separated by unrelated text. During prep, I dynamically stitched these fragments together to give the translator a clean, cohesive sentence. Now, using the markers I embedded earlier, I transfer the translated target text fragments back into their original layout positions without corrupting the underlying file architecture.

To ensure clear expectations and a smooth handoff, this final stage is defined by two key principles:

• The DTP boundary: While I meticulously restore the native tags, inline formatting, and structural architecture, I do not perform manual desktop publishing (DTP) adjustments (e.g., fixing page breaks or adjusting text boxes for expansion). The final visual polishing and post-DTP linguistic review remain your responsibility to execute in-house or with your chosen resources.

• Total transparency and asset delivery: I do not hold your data hostage. Upon completion, I deliver the final formatted native files, all intermediate files generated throughout the workflow, and the fully updated project translation memory.

This comprehensive handover establishes a crystal-clear audit trail of my entire process. It honors your ownership of the project assets and control over your data, fully equipped and ready to leverage those resources for your next project.