Product copy becomes localization-ready when it is single-sourced first: copy scattered across components as literals cannot be made localization-ready by rewriting it, because there is no agreed source to translate. Clarity work, glossaries and style guides all matter, but they only pay off after the strings live in one catalog. This page is the sequence, in the order that works.

Most advice on this topic starts at step two. It tells you to write in plain language, avoid idioms and give translators context, which is all good advice and none of it can be acted on while the same message exists in five slightly different forms across your components. The definitional background, and the argument for why the codebase should be the source of truth for product copy, is in code-native product copy. This page is the practical order of operations.

What does localization-ready mean?

It means a translator, or a translation tool, can be given your copy and produce a faithful version without guessing. That needs three conditions: every string exists in exactly one agreed place, each string says one clear thing, and whoever translates it can tell where and how it is used.

The three are not equally easy to retrofit. Clear wording can be improved a string at a time. Context can be added as notes. But "exactly one agreed place" is structural. If it is missing, the other two have nothing stable to attach to: you cannot improve a string whose twin lives in another file, and you cannot annotate a message that has no single address.

Why does the source cap the quality of the translation?

Because translation is derived work, and derived work inherits every flaw of what it derives from. A translation carries the ambiguity of the source into each target language, and it carries the inconsistency too. If the source says "Sign in" on one screen, "Log in" on another and "Login" on a third, you now have three terms in every language, translated independently, with no way to say which is the intended one.

This is also why the usual fix, polishing the translations, treats the wrong end. Every language you add multiplies the cost of an unfixed source. Fixing the source once fixes it everywhere, including in languages you have not added yet.

There is a name for the underlying failure. Copy drift is user-visible text diverging from its approved source across surfaces and over time, with no single source of truth. What is copy drift covers the causes. Localization is where it becomes expensive, because the drift gets copied into every language.

Why can't scattered copy be made localization-ready?

Because there is nothing to hand over. A literal inside a component is not a unit a translation step can pick up. It is mixed with markup and logic, it may be assembled from fragments, and the same sentence may exist in several files with small differences nobody chose.

Rewriting those literals in place does not change this. You can make each one clearer and still have no catalog, no agreed list of what the product says, and no way to know whether you found them all. The result is tidier text in the same scattered places.

The first step is therefore not an editing job. It is a collecting job: get every user-visible string into one catalog, one source language, in the repository, referenced by key from the components. Do it without changing wording. The point of this pass is to establish what the product currently says, including the parts that contradict each other.

How do you collect the strings?

Move them into a catalog first and improve them second. Two reasons for that order. A mixed pass, where you reword while you move, hides what changed from reviewers and from you. And once everything is in one file, duplicates and near-duplicates stop being invisible: they sit next to each other, and the cleanup becomes a matter of reading one file.

Practically:

  • Pick one catalog per source language, in the repo. A copy of record that both people and tools can read. How to lay it out and name keys is covered in how to keep UI copy consistent across a codebase; it is the same catalog, so that page is the layout reference and this one does not repeat it.
  • Replace the literals with key references. Every string a user can read, including button labels, error messages, empty states, tooltips and accessibility text, which are the usual stragglers.
  • Keep sentences whole. If a message is built by joining fragments, make it one entry with variables, so the unit a translator sees is the unit a user reads. Word order differs between languages, and a sentence assembled in code cannot follow it.
  • Do not reword yet. Resist it. You will find the awkward ones, so note them and move on.

If that list reads like a month of careful work across a large codebase, that is the honest cost of the step, and the reason it is where most teams stall.

What do you do once the strings are in one catalog?

Now the familiar advice finally has something to act on. With one catalog, each of these becomes a single pass instead of a hunt:

  1. Remove duplicates and near-duplicates. Pick the approved wording for each message and point every use at it.
  2. Fix the terms that must never vary. Feature names, the verbs for core actions, words you have decided not to use. Write them down once. This is your glossary, and it is short.
  3. Write plainly. Active voice, no idioms, no jokes that depend on one language's wordplay, acronyms spelled out where they could be misread. Each string says one thing.
  4. Give translators context. A note on where the string appears and what a variable stands for. Short strings such as "Post" or "Order" are the classic trap: noun or verb, and the target language may need a different word for each.
  5. Allow for length. Translated text is often longer than the source, so design layouts that do not break when a label grows. Treat that as a design constraint rather than a number to plan around.

Each step is quick because the catalog is the one place it happens. Without the catalog, the same five steps are five scavenger hunts across the codebase, and you never know when you are done.

What should you settle before you choose a translation vendor or tool?

The source and the review path. A vendor or tool translates what you give it. Give it a clean catalog and a short glossary and it can do good work. Give it scattered literals and you will pay to translate the inconsistencies, then pay again to correct them in each language.

Decide three things first. Which file is the source of truth. Who approves a wording change. And how a changed or new string reaches translation: by hand, by a script, or by a pull request that arrives with the translations attached. The last is the one that keeps translations from falling behind the source, the problem described in why translation files fall out of sync.

What changes when copy already lives in the repository?

Localization stops being a separate project. When the catalog is in the repo, a new or changed string shows up as a line in a diff, translations of it can be produced and reviewed through the same pull request flow as the code, and nobody has to export a spreadsheet and hope it comes back in order.

That is why, in a codebase, keeping copy consistent and keeping it localization-ready are the same operation. Both depend on one agreed source. Do the work once and you get both. Teams building with AI coding tools feel this sooner, because an agent will quietly reword or reintroduce a literal unless the catalog and a lint rule stand in the way; how to stop AI coding agents rewriting your UI copy covers that case.

Where globalize.now fits

globalize.now is a code-native copy management system with localization built in, and the single-sourcing step above is the part it does for you. You connect a GitHub or GitLab repository in the app. A scan works out what is there. If the strings are literals inside components, a one-time conversion moves them behind keys into a catalog and adds the i18n setup if there is none; if you already use a library such as next-intl, react-i18next, i18next or Lingui, it works with what you have. The result arrives as a pull request on its own branch, so the first catalog goes through exactly the review described above. After that, new source strings you add are translated by push jobs that open a pull request with the result. The repository stays the only source of truth, and the existing-i18n guide walks through what the scan finds when a setup is already there.

We are building toward the same discipline holding across the marketing site, the landing page and the product from one source. That is where we are heading, not something to buy today. Pricing is on the pricing page.

The order, in short

  1. Collect every user-visible string into one catalog in the repository. Do not reword.
  2. Keep sentences whole and reference every string by key.
  3. Remove duplicates and choose the approved wording once.
  4. Write the short glossary of terms that never vary.
  5. Edit for plain language and add context notes for translators.
  6. Decide who approves wording and how changed strings reach translation.
  7. Only then choose, or switch, the translation vendor or tool.

If the first step is the one that looks like a month of work, connect a repository, read the plan it proposes, and review the pull request it opens.

globalize.now turns hardcoded app copy into translation-ready locale files and keeps them updated as you ship.

Try globalize.now free