Running your practice
Agile Localization: How Translators and Agencies Work Inside Sprint Cycles
Agile localization embeds translation into sprint cycles so strings flow from the repo to the TMS continuously, with human review and LQA inside each release.
Translation agencies that still batch strings into weekly handoffs lose the sprint-shaped work to shops that have re-engineered their production floor around merge events. This page covers how translators and agencies restructure intake, roles, cadence, quality gates, and billing to deliver certified-grade output inside a client's two-week release train — without breaking the ISO 17100-aligned quality line. For the broader program this delivery model sits inside, see How App Localization Works and What Clients Are Buying.
What is agile localization from a translator's and agency's perspective?
Agile localization is a production method where translators work inside the client's sprint cycle: strings flow from the source repo into a TMS continuously, micro-jobs replace batch POs, and localized builds trail the English release by hours instead of weeks. For agencies, the model collapses the gap between dev merge and locale ship.
The operating shift touches five production levers at once:
- Intake: connector-driven string flow, not emailed XLIFF packages.
- Job size: micro-jobs of 10–200 strings, not multi-thousand-word POs.
- Roles: PM moves from dispatch to exception handling.
- Billing: retained capacity against an SLA, not per-PO quoting.
- Quality: review and LQA run in parallel inside the sprint, not after.
How does agile localization differ from traditional waterfall translation handoff?
In waterfall, strings are exported once per release, translated offline, and reimported weeks later. In agile localization, every merge pushes new or changed strings to the TMS, translators pick micro-jobs sized in minutes, and locales ship on the same sprint as source.
| Dimension | Waterfall localization | Agile localization |
|---|---|---|
| String intake | Batch export per release | Webhook on merge, diff-based |
| Job size | 5,000–50,000 words per PO | 10–200 strings per micro-job |
| Release-trail delta | Weeks to months behind source | Hours behind source |
| PM work | Quote, dispatch, chase files | Monitor queues, resolve blockers |
| Billing frame | Per-PO quoting | Retained capacity with overage |
| TM update cadence | Per batch close | Per approved segment |
In-sprint timing and release-trail mechanics are documented further in Product Localization: How Translators and Agencies Deliver It.
When does a project actually need agile localization?
A project crosses into agile localization when four triggers appear together: a release cadence under two weeks, more than 500 new or changed strings per sprint, more than six active target locales, and in-app experimentation that spawns strings outside the main release train.
- Release cadence under two weeks. Batch handoff cannot keep up with the merge rate.
- 500+ changed strings per sprint. Volume justifies a connector instead of manual exports.
- 6+ active locales. Coordination cost of parallel waterfalls exceeds a single continuous pipeline.
- In-app experimentation. A/B copy, feature flags, and in-product messaging ship between releases.
In-tool experimentation is one of the loudest triggers; see How Pendo Localization Works and What Translators Need to Know for the string-flow pattern when copy ships outside the main release train.
How it works
How does the agile localization workflow run inside a sprint?
1
How do strings move from the developer's repo into the translator's queue?
Strings move via a TMS connector: when a developer merges new or changed resource files, a webhook fires, the TMS diffs the keys, creates micro-jobs for only the affected segments, and routes them to the pre-assigned linguist pool for that locale. The repo stays untouched by translators; the TMS stays authoritative.
Common stacks for the source side include GitHub, GitLab, and Bitbucket, with CI pipelines handling the merge trigger. For a frontend-framework example, see React i18n: How Translators Fit Into a React Localization Pipeline. For broader multi-locale orchestration, see Localization Management: How Translators and Agencies Run Multi-Locale Programs.
2
What does a translator's day look like under agile localization?
A translator's day under agile localization is a feed of micro-jobs — typically 10 to 200 strings each, sized in minutes — picked from a shared queue, with translation memory and glossary pre-loaded, screenshots or Figma context attached, and an SLA counting down per job.
- Queue view: micro-jobs ranked by SLA, locale, and client priority.
- Context panel: screenshot, Figma frame, or in-app route for the string.
- TM and term base: pre-loaded per locale, with match percentages visible.
- AI first-draft: pre-filled for post-editing on new segments.
- Submit path: segment moves to reviewer, then to LQA sampling pool.
3
How does the PM role change in an agile localization setup?
The PM role shifts from job dispatch to exception handling and capacity planning: instead of issuing POs and chasing files, the PM watches queue health, resolves context questions, reroutes blocked segments, and forecasts linguist capacity against the client's roadmap.
A PM's day under this model includes five recurring tasks:
- Monitor queue depth and SLA burn-down per locale.
- Resolve translator context queries routed through the TMS.
- Reroute segments blocked by mutating source copy or missing assets.
- Forecast linguist capacity against the next 2–3 sprints of client roadmap.
- Report LQA scores per locale to the client and the quality lead.
What core technologies and tools make agile localization work?
Agile localization relies on four core technology layers: a translation management system with Git/CI connectors, a shared translation memory and term base per locale, AI first-draft and machine translation engines (DeepL, GPT-class, NMT), and webhook-driven integrations with GitHub, GitLab, or Bitbucket for real-time string sync.
| Layer | Function | Owner |
|---|---|---|
| TMS with connectors | System of record; routes micro-jobs | Agency |
| Translation memory + term base | Leverage and terminology consistency | Agency (per locale) |
| AI first-draft / NMT | Pre-translation upstream of human review | Agency |
| Repo + CI webhooks | Trigger diff and micro-job creation on merge | Client dev team |
What role does the TMS play as the system of record?
The TMS is the single system of record for every string, variant, and status: translators never touch the repo, developers never hand-edit locale files, and every change — source, translation, approval, LQA score — is logged against the segment ID for audit.
That audit trail is what lets ISO 17100-aligned agencies defend a per-segment chain of custody when a certified lane runs through an agile pipeline. Multi-locale governance of the same system of record is covered in Localization Management: How Translators and Agencies Run Multi-Locale Programs.
How does translation memory change under continuous flow?
Translation memory under continuous flow is updated per approved segment, not per batch, so leverage climbs sprint over sprint. Agencies govern one TM and one term base per locale across all client lanes to keep match rates stable and prevent fragmentation.
Per-segment updates have three operational effects:
- Leverage rises inside the same sprint, not after a batch close.
- Terminology drift is caught the moment a reviewer rejects a term.
- Fragmentation across sub-projects collapses when the TM is shared, not forked.
Where does AI first-draft and machine translation fit in the pipeline?
AI first-draft and machine translation sit upstream of human review: the engine pre-translates every new segment, TM overrides exact and high-fuzzy matches, and translators post-edit the AI output rather than translating from scratch — compressing turnaround without removing the human sign-off.
The stacking order is fixed: TM match → AI pre-translate on no-match → human post-edit → reviewer → LQA sample. Engines in common use include DeepL, GPT-class large language models, and domain-tuned NMT. CI-integrated branch flows that feed these engines are documented in Computer Software Localization: How Translators and Agencies Ship It.
Why us
What are the key benefits of agile localization for translators and agencies?
Agile localization delivers four measurable benefits to the production side: predictable linguist utilization through retained capacity, higher TM leverage from continuous updates, faster time-to-locale that justifies premium SLAs, and a PM workload that scales sub-linearly with string volume.
- Predictable utilization: reserved hours smooth the sawtooth of PO cycles.
- Higher TM leverage: per-segment updates raise match rates faster.
- Faster time-to-locale: locales trail source by hours, supporting premium SLAs.
- Sub-linear PM load: queue monitoring scales better than per-PO dispatch.
How do quality gates survive a two-week sprint cadence?
Quality gates survive agile cadence by running in parallel, not in series: review at $0.04–$0.08 per source word checks every segment, and LQA at $40–$90 per 1,000 words samples output against an MQM-style scorecard aligned to ISO 17100 covering accuracy, fluency, terminology, locale convention, and style.
What does the LQA scorecard check per sprint?
The LQA scorecard checks sampled segments against five error categories — accuracy, fluency, terminology, locale convention, and style — with severity weights that convert raw defects into a per-locale score that must clear the pass threshold before the sprint build ships.
| Category | Checks | Severity weights |
|---|---|---|
| Accuracy | Mistranslation, omission, addition | Minor / Major / Critical |
| Fluency | Grammar, punctuation, spelling | Minor / Major |
| Terminology | Term base adherence, consistency | Minor / Major |
| Locale convention | Date, number, currency, address format | Minor / Major |
| Style | Register, tone, brand voice | Minor / Major |
Do certified lanes (USCIS, legal) break under agile cadence?
Certified lanes do not break under agile cadence when LQA stays a blocking gate and the certificate of accuracy remains mandatory per page. USCIS filings still price at $0.10–$0.25 per source word or $25–$150 per standard page, with notarization an optional $10–$50 line item — sprint pressure is absorbed through parallel reviewer pools, not by skipping gates.
Three operational rules keep the certified lane intact:
- LQA sampling runs on every certified-lane sprint, not every other one.
- Reviewer pools are expanded in parallel when volume spikes.
- Per-page certificate of accuracy and sign-off are issued before the build cuts, not after.
Pricing
How do agencies price agile localization versus traditional project work?
Agencies price agile localization in four stacked line items on a retained-capacity frame: translation at $0.10–$0.25 per source word, review at $0.04–$0.08 per word, LQA at $40–$90 per 1,000 words, and PM at 10–15% of project value — with AI pre-translate shifting the mix toward review and LQA rather than translation.
| Line item | Rate | Basis |
|---|---|---|
| Translation (post-edit on AI draft) | $0.10–$0.25 / source word | Per word, per locale |
| Review | $0.04–$0.08 / source word | Every segment, per locale |
| LQA | $40–$90 / 1,000 words | Sampled against MQM scorecard |
| Project management | 10–15% of project value | Retained capacity + exception handling |
| Certified sign-off (USCIS) | $25–$150 / page | Per page, with notarization $10–$50 optional |
What does a mid-size agile localization program cost end-to-end?
A mid-size multi-locale program covering 5 languages and 50,000 words budgets at $25,000–$75,000 end to end, with AI pre-translate shifting the mix toward review and LQA rather than translation. Variation tracks TM leverage, turnaround SLA, and whether certified sign-off is in scope.
Three variables move the budget inside that band:
- TM leverage: a mature TM at 40%+ fuzzy-and-above match compresses translation cost.
- Turnaround SLA: 24-hour SLAs carry a premium over 72-hour SLAs.
- Certified scope: adding per-page certification raises the per-locale floor.
What breaks an agile localization program and how do agencies respond?
Agile localization programs break in five predictable ways: missing context on new strings, source copy that keeps changing after translation, connector drift between repo and TMS, reviewer burnout on micro-job cadence, and locale-specific QA bugs that only surface in staging builds.
- Missing context: enforce screenshot or Figma link on every new string key.
- Mutating source copy: lock copy at sprint start or price re-translations as overage.
- Connector drift: run a scheduled key-parity check between repo and TMS.
- Reviewer burnout: cap micro-job queue depth per reviewer per day.
- Locale QA bugs: ship pseudo-localization builds to staging each sprint.
How is a readiness check run against a prospective agile localization client?
A five-row readiness check scores a prospect before an agile retainer is signed: connector availability for the client's stack, internationalization hygiene (externalized strings, no hard-coded dates), string-volume floor above 500 per sprint, in-tool context delivery (screenshots or Figma links), and a budgeted LQA line.
| Row | Check | Pass criterion |
|---|---|---|
| 1 | Connector availability | Supported TMS connector for the client's repo and CI |
| 2 | i18n hygiene | Externalized strings; no hard-coded dates, numbers, or currency |
| 3 | String-volume floor | 500+ new or changed strings per sprint |
| 4 | Context delivery | Screenshots or Figma frames attached per string key |
| 5 | LQA budget line | $40–$90 per 1,000 words line item approved |
Per-locale emission on the published output still follows standard tagging: ISO 639-1 language codes with optional ISO 3166-1 country codes, for example hreflang="es-MX" and hreflang="pt-BR", applied per locale build.
Frequently asked questions
What are the best practices for doing localization (software)?
The best practices for software localization center on integrating translation work directly into the development sprint cycle rather than treating it as a post-release afterthought. Key practices include: internationalizing the codebase first (i18n) so strings are externalized and context-tagged before any translation begins; assigning a dedicated localization engineer or LSP contact to each sprint; committing to continuous localization by pushing new or changed strings to translators within 24–48 hours of a string freeze; and using translation memory (TM) to avoid re-translating repeated UI strings across sprints, which typically reduces per-word costs by 20–40%. For certified content — such as in-app legal notices, compliance disclosures, or onboarding documents — first-draft automation tools can compress turnaround from days to hours, keeping pace with two-week sprint cadences without sacrificing quality or certification requirements.
Related
- Application Localization: The Translator's and Agency's Guide
- Bad Localization: What Goes Wrong and How to Avoid It
- Business Localization: How Agencies Deliver Multi-Locale Programs for Corporate Clients
- CAT Tool: What It Is, What It Does Inside a Translator's Workflow
- CAT Tools for Translation: What They Do and Which Ones Translators Actually Use
- CMS Localization: How Translators and Agencies Produce Multilingual Content Across Platforms