Continuous localization — keep translations in sync with every release.
Stop freezing releases for translation handoffs. Continuous localization moves new strings from your code to your translators automatically, runs translation in parallel with development, and ships approved updates to users via CDN — without redeploying.
Locize was built by the team behind i18next. The same saveMissing handler i18next exposes is the integration point — your application pushes new strings to Locize as it runs, and translations come back via the Locize CDN with no rebuild required.
- Release freeze
- Export translation files
- Email to translators
- Wait days / weeks
- Import back
- Redeploy
- No freeze — keep shipping
- Auto-sync via saveMissing
- Translators work in parallel
- AI translation pre-fills
- Review workflow gates publish
- CDN delivery — no redeploy
What is continuous localization?
A translation workflow that runs in parallel with continuous integration and continuous delivery — instead of as a release-blocking handoff.
Continuous localization is the translation equivalent of continuous deployment. New strings added by developers flow automatically from the codebase into the translation management system. Translators (or AI translation, or both with human review) process those strings in parallel with development. Approved translations are published to a Content Delivery Network and delivered to your running application — without rebuilding or redeploying.
The shift is from batch handoffs (export files, email, wait, import, redeploy) to always-on flow (push to TMS, work in parallel, publish to CDN, deliver instantly). The effect on engineering teams: translation stops being a release-blocking dependency, and translation fixes ship in minutes instead of a release cycle.
Why teams switch to continuous localization
Three problems that batch translation workflows create — and that continuous localization solves.
When translation is a handoff before release, every shipped feature waits for the slowest language to be translated. Continuous localization decouples the two: features ship to your default language immediately, and translations catch up in the background — never blocking the release train.
A typo in a Polish accessibility statement should not require a release. With CDN-delivered translations, fixes go live as soon as a translator approves them — no rebuild, no redeploy, no waiting for the next release cycle.
Adding a new language traditionally meant a project plan: export, translate, QA, integrate, release. With AI translation + human review running continuously, adding a language is hours of work, not weeks. The TMS handles the rollout.
How continuous localization works
Four stages, running continuously alongside your CI/CD pipeline.
When developers add a new translation key in code, it flows automatically to the TMS — either via the i18next saveMissing handler (which pushes from a running application), via a CLI step in your CI pipeline (Locize REST API / locize-cli), or via direct API calls. No manual export required.
Translators work on new strings in parallel with ongoing development. AI translation can pre-fill translations using your project glossary and style guide as context; the review workflow gates which translations get published. In-context editing lets translators edit strings on the live site.
Approved translations are automatically published to the Locize CDN. Both Standard (Bunny CDN) and Pro (Amazon CloudFront) tiers are available, with per-version cache-control. Branches and versioning let you stage changes before promoting to production.
Your running application fetches translations from the CDN at runtime. New translations appear in your live app without a rebuild or redeploy. Per-key cache-control settings let you tune the latency-vs-freshness tradeoff per version.
Continuous vs. traditional translation workflows
The same goal — multilingual product — but a fundamentally different operating model.
| Aspect | Traditional batch workflow | Continuous localization |
|---|---|---|
| New string flow | Manual export at release cut | Automatic via saveMissing / API / CLI |
| Translator timing | Sequential — after dev freeze | Parallel with development |
| Delivery | Bundled into application build | CDN-delivered at runtime |
| Fixing a typo | Next release cycle | Minutes — CDN update |
| Adding a language | Multi-week project | Hours — AI pre-translate + review |
| Release blocking | Yes — translation gates release | No — default language ships immediately |
| Audit trail | Email threads, file versions | Per-key history, audit log, reviewer identity |
How Locize delivers continuous localization
The technical stack that makes "continuous" actually continuous.
Locize was built by the same team that maintains i18next. The saveMissing handler in i18next is the natural integration point — your running application pushes new strings directly to your Locize project. Configure it via i18next-locize-backend.
Automatic Translation pre-fills translations using OpenAI, Gemini, Mistral, DeepL — bring your own API key (BYOK). Your project glossary and style guide are injected into the AI prompt for terminology consistency. The review workflow gates which AI translations get published.
The Locize CDN delivers translations globally. Standard uses Bunny CDN (cost-efficient, global edge); Pro uses Amazon CloudFront (enterprise SLAs, advanced caching). Both support per-version cache-control and private publishing.
Branches let you work on translations for a new feature in isolation. Versioning separates staging from production. Per-key history and audit log capture who changed what, when — required for regulated industries and useful for everyone.
The in-context editor lets translators edit strings directly on the live website or app. i18next-subliminal markers ensure exact string-to-key matching, even when the same English text appears in multiple places.
locize-cli handles bulk operations from your CI pipeline — download, upload, validate completeness, fail builds on missing translations. The REST API covers the same operations programmatically for non-i18next stacks.
Teams shipping continuously with Locize
With the introduction of Locize, we had an overview of the status of translations or which text content still needed to be translated from the very beginning.
Thanks to the very flexible API, the current texts are integrated in every build (for technical reasons, ZKB cannot use an external CDN).
The handling is self-explanatory for translators.
Locize also has excellent support and very reasonable conditions.
Being a Swiss Startup, we had to launch our website in several languages at once. We used i18next with React and were translating JSON files by hand, which was really cumbersome.
Locize really changed everything for us because it allowed us to let non-developers translate the website pages.
Decouple the translation process from application deployments.
Use Google Translate straight from within the tool. Really recommended.
Thanks to the generous support and the features of Locize, the headless websites of the Swiss Red Cross can be translated into different languages within a short time!
We're using Locize for several projects, which offers different services for our international partners in the whole world.
Thanks to Locize our localization workflow is faster, more efficient and modern.
When does continuous localization matter most?
Continuous localization is overkill for some teams and load-bearing for others. Here's how to decide.
- You ship multiple times per week and translation is a release dependency
- You operate in regulated EU markets where translation fixes need to ship fast (EAA, Web Accessibility Directive)
- Your product has frequent micro-copy changes — A/B tests, error messages, onboarding flow tweaks
- You support 10+ languages and manual coordination has become a bottleneck
- You're a SaaS or e-commerce platform with always-on availability requirements
- You ship a few releases per year and translation can fit into the release schedule
- Your content is mostly static marketing pages with low change frequency
- You have only 1-2 target languages and translation is a single-person responsibility
- Compliance / regulated content requires the deliberate handoff process anyway
Even in these cases, the CDN delivery aspect is usually still worth it — even a slow-moving site benefits from being able to fix a typo without a redeploy.
Frequently asked questions
If your question is missing, email support@locize.com
Continuous localization is a translation workflow that runs automatically alongside continuous integration and continuous delivery (CI/CD). New strings added by developers flow automatically from the codebase to the translation management system; translators (or AI translation) work on them in parallel with development; and approved translations are delivered to end users via CDN — without redeploying the application. The core idea: translation stops being a release-blocking handoff and becomes a parallel, always-on background process.
A continuous localization pipeline has four stages: (1) Capture — new strings are detected and synced to the TMS, typically via an SDK hook like i18next saveMissing, a CLI in your CI pipeline, or a REST API call; (2) Translate — strings are translated by humans, by AI/machine translation, or by both with human review; (3) Publish — approved translations are published to a CDN; (4) Deliver — your running application fetches translations from the CDN without a redeploy. The pipeline runs on every commit, every release, or every push to the TMS.
Traditional translation workflows are batch handoffs: developers freeze a release, export translation files (JSON, XLIFF, .po), send them to translators or an agency, wait days or weeks, import the translated files back, redeploy. Continuous localization eliminates the freeze and the redeploy: new strings flow automatically, translators work in parallel with development, and updates ship via CDN without a release cycle. The practical effect is faster time-to-market for new languages and the ability to fix a translation typo in minutes instead of a release cycle.
Yes — continuous localization is the default Locize workflow, not a separate feature. Locize was built by the team behind i18next, and the same saveMissing handler i18next exposes makes it trivial to push new strings from your running application directly into Locize. Translators or AI translation can then process those strings (with optional review workflow). Approved translations are automatically published to the Locize CDN — both Standard (Bunny CDN) and Pro (Amazon CloudFront) are available. Branches, versioning, per-key history, and audit log support the workflow at production scale.
Three integration points usually cover it: (1) instrument your application with i18next + i18next-locize-backend so new strings sync automatically via saveMissing — no CI change needed; (2) add a CI step that exports / verifies translation completeness before deploys (the Locize CLI can do this); (3) configure your production environment to fetch translations from the Locize CDN instead of bundling them, so translation updates do not require a redeploy. For non-i18next stacks, the Locize REST API and CLI cover the same operations. Frameworks supported: React, Vue, Angular, Svelte, Next.js, Node.js, Deno, vanilla JavaScript, and any framework that loads JSON translations.
CDN-based translation delivery means your application fetches translation files from a Content Delivery Network at runtime — instead of bundling translations into the application build. The practical effect: when a translator fixes a typo or adds a new language, the change goes live immediately, without rebuilding or redeploying the application. This is the technical mechanism that makes "continuous" actually continuous. Locize offers both Standard (Bunny CDN) and Pro (Amazon CloudFront) tiers, with per-version cache-control and private-publishing options.
Further reading on continuous localization
The whole product walkthrough: connect, translate with AI, route through review, deliver via CDN — in one read.
A practical look at classic vs. modern continuous localization workflows — and how to keep translations in sync with fast-moving development.
The evolution from traditional to agile development with continuous integration — and how localization fits into the same shift.