Drupal translation workflows with TMGMT

Drupal translation workflows with TMGMT send source content to translators or translation services as jobs, route them through review and keep translations aligned when source content changes. This page covers the decisions, build sequence and effort drivers behind that setup.

On this page

Drupal translation workflows with TMGMT: when teams build them and what they cover

Teams build a TMGMT workflow when a multilingual Drupal site relies on translators or a translation service outside the editorial team and the translated content must move in and out of Drupal without copy and paste. The Translation Management Tool (TMGMT) is the contributed module for that job. It sends content from different sources to people or translation services of all kinds, and it builds on Drupal's language system, so the site's content languages, translatable fields and language negotiation still decide what can be translated. Its 8.x-1.19 release supports Drupal ^10.3 or ^11, which is the first check to run against your planned core version. Confirm the current release notes on the Drupal.org TMGMT project page before you commit to a version.

Drupal and contributed modules hosted on Drupal.org are licensed under GPL-2.0-or-later, so TMGMT carries no license fee. The money goes elsewhere: the build of the job workflow and review steps, any connector work for your translation providers, testing against real content, and the translation services themselves, which are usually billed per word or per job and recur with every content change. Ask each vendor for their pricing model and turnaround terms in writing, and ask the implementation partner to separate one-time build effort from ongoing connector maintenance in the quote.

The decision that shapes the rest of the project is whether your providers have a connector that already fits your workflow or whether one must be written or adapted. Before scoping, list the translatable entities, the review steps your editors expect, and how source updates should flag existing translations as outdated. Those answers determine how much custom work the build needs and how much recurring effort the workflow will demand after launch.

What the module does according to its documentation

A translation request in TMGMT starts as a job that records the source language, the target language and the translator assigned to the work. Each source entity the job covers is tracked as a job item, so one job can hold several pieces of content and each item keeps its own status. The module builds on Drupal's language system, which determines the languages that can be requested. Confirm which entity types, bundles and fields your chosen release can send before you define the content scope for each job.

  • Job: the request that holds the language pair and the assigned translator or provider.
  • Job item: one source entity or content unit tracked through the workflow.
  • Job states: each job and item moves through named states, so confirm the exact state names in the release you deploy.
  • Grouping: related items can be sent together so a translator receives a coherent set of content.
  • Source selection: the entity types and fields available for translation depend on the release and its configuration.

Check the project documentation for the supported entity types and the state model before you map your editorial workflow onto jobs.

Capabilities teams plan around in TMGMT

The Translation Management Tool gives a Drupal site a job-based way to send content out for translation and bring the results back for review. Each capability below is a decision point that shapes how much work the workflow needs and who owns it.

Translation jobs and items

A TMGMT job groups the content entities sent to a translator or service for one target language, and each item tracks a single entity's translation state. Plan how editors will batch content, which entity types and fields are in scope, and how a job is requested, accepted and completed. Confirm how your chosen version reports job status to editors who need to know what is still in progress.

Translator and provider connectors

Connectors link TMGMT to the people or services that do the translating, such as a translation memory service, a machine translation engine or a manual translator workflow. Each connector has its own credentials, pricing model, file formats and error handling, so the behavior depends on the provider. Confirm with each provider which formats, callbacks and quota limits its connector supports before you commit to it.

Review before publication

Translated text usually returns as a draft that an editor must check before it goes live. Decide whether reviewers work inside Drupal's translation interface or in the provider's tool, and where the approval step sits relative to Content Moderation if your site uses it. Ask the provider whether returned translations can be edited in Drupal without overwriting later provider updates.

Source change tracking

When an editor changes the source content after a translation exists, the translation may be outdated and needs a clear state. Define how TMGMT flags outdated translations, who decides whether to re-send the source, and whether partial updates are allowed. Test this with a realistic edit sequence before launch, since it is the most common source of stale content on multilingual sites.

Language mapping on Drupal's language system

TMGMT builds on Drupal's language system, so source and target languages must already be configured in the site. Map each provider's language codes to the codes Drupal uses, and check regional variants such as separate British and American English. Mismatched codes are a frequent cause of jobs that cannot be created or content that lands in the wrong language.

Permissions for translators

Translators and reviewers should see only the jobs and languages assigned to them. Plan roles that separate people who create jobs, people who review translations and external translators who may need limited access. Confirm how TMGMT permissions interact with your existing editorial roles before giving external users accounts.

Configuration decisions before the first job is sent

This table compares the configuration choices that shape a TMGMT project before any job leaves the site. Read each row as a decision: the option, when it fits, and what it costs you later. The main takeaway is that scope, provider model and review location are hard to change once translators are working and content is already in flight.

DecisionOptionWhen it fitsTrade-off
Entity types and fieldsTranslate only selected node types and text fieldsMarketing pages and articles where a few fields carry the copyLess to translate and review, but fields left out must be handled by hand when content grows
Entity types and fieldsTranslate all translatable entities, including menus, taxonomy and configSites where navigation and taxonomy labels must reach every languageBroader scope drives job size, review load and reconciliation work
Who translatesHuman translators inside the organizationContent with strict terminology or confidentiality needs and a small language countCapacity depends on internal staff, and throughput is harder to forecast
Who translatesA translation service connected through a TMGMT connectorSeveral languages, volume that varies, or a provider already under contractConnector support, provider accounts and per-job terms must be confirmed before build
Who translatesA mix of internal reviewers and an external providerRegulated content where a named internal approver signs off on external outputTwo review paths need clear ownership and separate job states
Where review happensIn Drupal, using TMGMT job review and the content editing formWhen editors need to see translations in context on the live entityReviewers need Drupal access, and external translators may not be able to work here
Where review happensIn the provider's tool, with results returned to DrupalWhen the provider's linguists already work in their own platformReview history and quality data sit outside Drupal, so audit evidence needs a defined export
Source updatesFlag existing translations as outdated when the source changesContent that changes often and must stay accurate in every languageEditors may see outdated flags on many nodes, which needs a re-translation plan
Source updatesKeep published translations live until a new one is acceptedSites where a stale translation is better than noneReaders may see older wording for a period, so the policy needs an owner
Requesting and accepting jobsLimit requests and acceptance to named rolesTeams where translation spend and provider access need approvalExtra roles and permissions require testing before go-live

How a TMGMT rollout moves from language setup to live translations

The sequence runs from confirming the Drupal and language setup through to a tested, handed-over translation workflow, with each step closing on a check the team can verify. Following the order keeps provider decisions and publishing rules from being retrofitted after editors have already started sending content.

  1. Confirm Drupal version and language configuration

    Confirm the Drupal core version the site runs and that the TMGMT release you plan to install supports it. The TMGMT 8.x-1.19 release supports Drupal ^10.3 or ^11, so a site on an unsupported version needs its upgrade settled first. Then confirm the enabled languages, the default language, and the language detection and content negotiation settings. Done means the site runs a supported core, the language list is final, and the team has written down which languages are source and which are targets.

  2. Decide translatable content and fields

    Inventory the content types, taxonomy terms, menus, blocks and configuration that editors will send to translators, and mark which fields are translatable and which are shared across languages, such as images, dates and reference fields. Record the decision per content type in a short sheet that the content and development leads both sign. Done means every content type in scope has a translatability decision and no field is left to default behavior by accident.

  3. Configure translation providers and translator accounts

    Install TMGMT and the connector modules that match your provider, then create translator provider entries with the credentials the vendor or internal translation team issues. Store those credentials through your secrets handling process rather than in exported configuration. Confirm with each provider which language pairs, file formats and turnaround arrangements they support, since these are contractual points outside Drupal. Done means each provider can be selected in a test job and returns a connection status without errors.

  4. Set review and publishing rules

    Define who creates jobs, who reviews translated items, and who may publish them. Map these roles to Drupal permissions and decide whether a reviewed translation publishes directly or goes through Content Moderation first. Document what happens when the source changes while a job is open, so reviewers know whether to accept, update or discard the pending translation. Done means a written rule set exists and each role has been assigned the permissions it needs, with nothing broader.

  5. Test a job end to end on a staging copy

    On a staging copy of the production database, create a job for a small set of representative nodes, send it to each provider, return a translation, review it, and publish it. Also edit the source node during an open job to confirm the update behavior matches the rule set. Keep a log of each state change and any error. Done means one job has passed through every state in the workflow on staging, and the team has a list of defects fixed or accepted.

  6. Train editors and translators

    Run separate sessions for content editors, who create jobs and review output, and for the translators or vendor coordinators, who work with the files or the provider portal. Cover the review screen, how source changes affect open items, and what to do when a provider returns an error. Provide a short written guide that matches the configured site, not generic TMGMT documentation. Done means each trainee has completed one job on staging under observation.

  7. Hand over with runbooks and an update plan

    Hand over the configuration, provider credentials location, the staging test log, the role and rule documentation, and a runbook for failed jobs and stuck translations. Agree an update routine for TMGMT, Drupal core and the connector modules so that future security and bugfix releases are applied on a known schedule. Confirm who owns provider relationships after launch. Done means the client team can run a job without the implementation team present and has signed off the handover package.

What drives effort and cost in a TMGMT build

This table lists the main drivers behind a Drupal translation workflow build with TMGMT, how each one moves cost or effort, and what to ask for in a quote. Read each row as a question to answer before scoping, since most drivers compound when several apply at once.

DriverWhy it moves cost or effortWhat to ask for in a quote
Languages and localesEach target language adds job routing, review passes, translator matching and QA of rendered pages. Locale variants such as regional spellings add review work beyond the base language.Itemized list of language pairs and locales, and whether each one is priced separately
Content volume and field complexityLarge node counts and many translatable fields increase job sizing, source-change detection and testing. Entity references, Paragraphs and computed fields need extra rules for what is sent and what is ignored.Estimated content types, field counts and a sample of the fields in scope for translation
Number and type of providersEach provider needs its own connector or configuration, credentials, file formats and status handling. Human agencies, machine translation and internal translators follow different review paths.Named providers, their connection method and whether each one needs a separate connector
Custom connector workProviders without a maintained connector require custom plugin code for quotes, job submission, file exchange and status callbacks. This is usually the least predictable line item.Whether a maintained connector exists for each provider, and a written list of custom plugin work with acceptance tests
Review workflow complexityMulti-step review, in-context editing, partial approvals and rework loops add roles, notifications and test cases. Simple single-reviewer flows cost less to build and to support.Written review steps, roles per step, and how rejected or partial translations return to the queue
Integration with Content Moderation or WorkflowsTying translation states to moderation states means defining which transitions trigger jobs and which block publishing. Mismatched states are a common source of rework.A state mapping table covering draft, review, translated and published states, and who owns each transition
Source update and sync rulesDeciding how source edits flag existing translations, whether reviewers see changed segments and how stale translations are handled drives ongoing effort more than initial setup.Documented sync behavior for edited source content and the test cases used to confirm it
Upgrade path across Drupal majorsThe module's supported Drupal range and any custom connector code must keep pace with core upgrades. Custom plugins that are not maintained add upgrade work at each major release.Confirmed supported Drupal versions for the module release in scope, and who maintains custom connector code after launch

How TMGMT connects to the rest of a Drupal platform

How does TMGMT use Drupal's core language and content translation system?

TMGMT builds on Drupal's language system, so it can only translate what Drupal already knows how to translate. Content entities, fields and configuration must be marked as translatable before a job can carry them. Each translation job reads the source entity in its source language and writes the result back as a translation of the same entity, which means the content model decides what can be sent. Confirm during scoping which content types, fields, menus and configuration items must be translatable, and whether any of them are defined in custom code that needs changes. Review the module's own documentation on the Translation Management Tool project page against the Drupal version you run, since the 8.x-1.19 release supports Drupal ^10.3 or ^11.

Can editors review translations through Content Moderation before publishing?

Yes, but the two systems do not coordinate on their own, so the workflow must be designed on purpose. Content Moderation controls the state of a source or translated revision, such as draft, review or published. TMGMT controls the job that produces the translation. A common design lets a translator deliver a draft translation, a reviewer approve it in a moderation state, and only then does the translation become publishable. Decide which states apply to translations, who may move content between them, and what happens when the source changes while a translation is in review. Confirm this with the TMGMT version and the Content Moderation configuration in your own environment, because state handling for translations needs testing before you rely on it.

How do Drupal permissions limit who can send, accept and publish translations?

Drupal permissions decide who can create jobs, see them, accept returned work and publish the result, and these rights are separate from the rights to edit the source content. A translator account should usually see only the jobs assigned to it, while a project manager can create and track jobs across languages. Editors in one market may need access to content in their language only. Map each role to the TMGMT permissions and to the content permissions on the source node, then test with real accounts. Watch for the case where a user can accept a translation they did not create, since this bypasses review. Ask your team to document the role matrix before build, because permission gaps are hard to see until content is already in the queue.

Why do search indexes need to reflect translated content?

A search index only returns content it has indexed in the language you query, so translated nodes must be indexed as their own items in the right language. If the index is configured only for the source language, a French visitor may never find a translated page, even though the page exists and renders correctly. Configure the Search API index so translations are included, with language-specific fields and analysis for each supported language. Confirm the index behavior after each translation is published, and check that unpublished or in-review translations are excluded from public results. If you use Solr or another external engine, plan how reindexing runs when a batch of translations is approved, because large batches can take noticeable time to process.

What does multilingual SEO need from translated pages, such as hreflang?

Each translated page needs its own indexable URL, a correct language attribute, and hreflang annotations that link it to the equivalent pages in other languages. Without these, search engines may treat translations as duplicates or show the wrong language to users. URL aliases, the language switcher and the sitemap must all include the translated versions. Ask the SEO owner to confirm the URL structure, whether each language has its own path or domain, and how untranslated items fall back. Test hreflang output after the first published batch, since a missing return link between two pages breaks the pair. Consider this part of the translation scope, not an afterthought, because changing URL structure after launch affects rankings for every language.

How do external translation services and CAT tools connect to TMGMT?

TMGMT sends jobs to translators through translator plugins and connectors, which are separate modules that handle the exchange with a human translator, a translation agency or a computer-assisted translation (CAT) tool. Each connector has its own setup, authentication, file formats and status handling, so a service you choose defines much of the integration effort. Confirm which services your organization already contracts with, whether they offer an API or file exchange, and whether a suitable connector exists for your Drupal version. Also confirm where translated content is stored during transit, how credentials are kept, and whether the provider's data processing terms fit your data classification. Verify that the connector is maintained for your Drupal version before you commit to a design.

Keeping translations in sync when source content changes

The core sync problem is simple to state: once an editor changes the source node after a translation was ordered or completed, the existing translation no longer matches what the source says, and nothing in the content itself tells readers so. Before launch, the team needs one written rule that answers three questions: how a stale translation gets flagged, who decides whether it is re-requested from the translator or fixed in place, and who reviews the change before it goes live. Without that rule, each editor makes a different call, and the French or German page quietly drifts from the English original for months.

The decisions this forces start with the scope of a change. Teams should decide which source fields count as material, for example a headline or a price, and which are cosmetic, such as a tag or an internal note, because a full re-translation for a typo is expensive and a missed change in a legal or pricing field is a compliance problem. They also need to decide what editors see during the gap between a source edit and a finished translation. Options include showing the outdated translation with a visible notice, hiding it until review is complete, or falling back to the source language. Each choice affects search indexing, SEO signals and what a reader in another market can see, so the choice should be made with the content owners and not left to the developer who configures the module. Confirm the exact flagging behavior of the TMGMT release you plan to use, since the sync and review features depend on the connectors and the configuration of your content types.

Questions buyers ask before bringing in a partner for TMGMT

Is the TMGMT module itself paid for?

No. The Translation Management Tool is a contributed module licensed under GPL-2.0-or-later, the same license as Drupal core, so there is no license fee for the module itself. Drupal and its contributed modules have no paid edition. The cost sits in the work around it: planning the workflow, configuring translation jobs and review steps, building or configuring connectors to your translation vendors or translation tools, testing, and keeping the setup working after launch. Translator and vendor fees are a separate line that your translation provider or agency sets under its own contract. Ask any partner to separate module-related work from vendor charges in the quote, and confirm which connector licenses, if any, your chosen translation service requires.

What drives the cost of a TMGMT build?

The main drivers are the number of language pairs, the number of content types that must be sent for translation, how many translation services or connectors are involved, and how complex the review and approval path is. Other factors include whether translators work inside Drupal or in an external tool, how much translated content must be checked against source changes, and how much existing content must be backfilled into the workflow. One-time costs cover design, configuration, connector work and testing. Recurring costs cover updates, support and any changes when new languages or vendors are added. Ask for a quote that lists each language pair, connector and review step as separate line items so you can see what each addition costs.

How long does a TMGMT project take?

Duration depends mostly on scope, not on the module. A single language pair with one translation service and one review step is a much smaller piece of work than several languages, multiple vendors and a multi-stage approval chain. Other drivers include how many content types are in scope, whether the content model is already clean, the state of your Drupal site, and how quickly your team confirms decisions about job states, review roles and notifications. The timeline should be agreed in the written scope before work starts, with milestones for configuration, connector testing, a pilot with real content and rollout. Ask any partner to show which milestones depend on your team's decisions.

What does our internal team need to provide?

Your team needs to supply four things before the build can finish. First, the list of languages and the locale codes each market needs. Second, named content owners who approve source content, decide what is ready for translation and sign off on translated versions. Third, translator or vendor accounts with the access the connector requires, plus the contact people who handle job questions. Fourth, a decision on who acts as reviewer and who can publish. Engineers will also need a test site, access to the Drupal environments, and a clear rule for how source updates should affect translations already in progress. Missing any of these usually delays testing rather than the code.

Can an in-house team build TMGMT workflows without a partner?

Yes, an in-house Drupal team can build a TMGMT workflow if it has the skills to configure contributed modules, manage translation sources and targets, and test job states end to end. The Translation Management Tool builds on Drupal's language system, so a team already comfortable with multilingual Drupal will have the strongest starting point. The main risks are the time needed to learn the module, testing edge cases such as source updates during active jobs, and ongoing ownership once the original builders move on. A partner can be useful for a short scoped engagement, a review of the design, or support after launch. Decide early which parts your team will own and which you want documented for future maintenance.

How do Drupal version upgrades affect a TMGMT setup?

TMGMT must match the Drupal version your site runs. The current 8.x-1.19 release supports Drupal ^10.3 or ^11, so a site on an older Drupal line will need a different path before TMGMT can be used. Drupal 11 is the current major version, Drupal 12 is scheduled for the week of December 7, 2026, and Drupal 10 reaches end of life on December 9, 2026, according to the core release schedule. Plan a test upgrade of the module, your connectors and your job configuration before each major version. Check the module's compatibility with the target Drupal release, then retest translation jobs and review steps. Drupal 10 requires PHP 8.1 or later, Drupal 11 requires PHP 8.3 or later and Drupal 12 requires PHP 8.5 or later, so confirm the runtime as well.

How do we keep translations in sync when source content changes?

Start by deciding what a source change means for work already in progress. Some teams flag the translation as outdated and request a new job, while others allow editors to review changed fields only. The TMGMT project page describes the module's job and translation handling, so have your engineers confirm how the chosen version behaves when a source node is edited during an active job. Build test cases for these scenarios: edits during translation, edits after publication, deleted source content, and new fields added to a content type. Assign an owner for the outdated-translation queue so changes do not sit unnoticed.

How DeployOpen scopes and delivers TMGMT translation workflows

DeployOpen plans, builds, documents and supports Drupal translation workflows with TMGMT inside your own infrastructure. Each engagement starts with a written scope that sets out which content, languages, translator connections and review steps are covered before any build work begins.

How we scope

  • Inventory the content types, fields and languages that will be sent to translators or translation services
  • Map each translation job to a review step, an owner and an approval point agreed with your editorial team
  • Confirm which TMGMT connectors your translators or services need, and check each one against your Drupal version
  • Agree in writing the scope, deliverables and timeline, since most engagements are fixed-scope

How we build

  • Configure translators, job workflows and review states on a staging copy of your site before production use
  • Build or adapt connector code where a translation service lacks a suitable module, following your coding standards
  • Test source-update handling so changed content flags affected translations for review rather than overwriting them silently
  • Verify permissions, language settings and job notifications with your editors and translation coordinators

How we hand over

  • Document the job lifecycle, translator setup, review steps and recovery procedures for your editors and administrators
  • Record module versions, connector configuration and Composer dependencies so your team can reproduce the build
  • Run a walkthrough with the people who will create, review and publish translated content day to day
  • Agree which configuration stays under version control and who approves changes to translator settings

How we support

  • Support is available as a retainer covering module updates, security releases and connector maintenance
  • Plan upgrades of Drupal and TMGMT together, checking the module's stated compatibility before each step
  • Review translation job backlogs, failed connector calls and sync issues with your operations team on an agreed schedule
  • Ask any provider to confirm the support terms, response expectations and exit arrangements in the written quote

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.