Lorixen.
EN

Translating your app's text without chaos: a sequenced plan

Short answer: Localising an app goes smoothly when you treat text as data, not code. First move every user-facing string into your platform's string files, then handle plurals and variables properly, give translators context and character limits, test layouts with a pseudolocale before real translations arrive, and only then translate, review in the running app and release. Most chaos comes from translating before the strings are clean.

Founders building apps in Berlin, Munich or Vienna often launch in English and then need German, or the reverse, plus a third language later. The first attempt usually involves a spreadsheet of sentences copied out of the app, translations pasted back in by hand, and German words spilling out of buttons. This plan puts the steps in an order that avoids that.

Phase 1 (week 1): Get every string out of the code

Before anyone translates anything, every piece of user-facing text should live in the platform's localisation files rather than hard-coded in screens.

  • iOS and macOS: Apple's string catalogs (Localizable.xcstrings) keep localisable strings in one place with a visual editor in Xcode. Apple's documentation explains that when you build the project, Xcode discovers localisable strings and adds them to the catalog automatically, and updates the catalog as you change strings in code. Most SwiftUI strings inside views are localisable automatically.
  • Android: string resources in XML files, referenced from code, with separate folders per language. Android's documentation describes three types: single strings, string arrays and quantity strings (plurals).
  • Web apps: a message file per language (JSON or similar) loaded by your internationalisation library.

Also find the text people forget: error messages from the server, push notification templates, emails, app store listings and images that contain words.

Phase 2 (week 2): Fix the strings that can't be translated

Some strings are written in ways no translator can handle. Fix them now:

  • Sentences built from pieces. "You have " + count + " new " + item is impossible to translate correctly into many languages. Use one complete string with placeholders.
  • Plurals done with if-statements. Android's documentation points out that languages have different plural rules: English treats 1 as special, while other languages make finer distinctions. Android supports the categories zero, one, two, few, many and other, and provides methods to pick the right one. Apple's string catalogs add plural variants per language. Use these features instead of "item(s)".
  • Placeholders without names. "%@ invited %@" gives a translator no clue which is which. Use named or numbered placeholders and describe them.
  • Text in images. Replace with real text or provide image variants.

Phase 3 (week 3): Add context for translators

Translators work from lists of strings, often without seeing the app. Give them what they need:

  • A comment on every string describing where it appears and what it does: "Button on checkout screen; confirms the order". Apple notes that string catalogs can generate comments; review and improve them.
  • Character limits for tight spots such as buttons, tabs and notifications.
  • Screenshots of key screens.
  • A glossary: your product name, feature names and terms that must stay consistent ("booking", not sometimes "reservation").
  • Tone guidance: for German, decide early between formal "Sie" and informal "du" and apply it everywhere.

Phase 4 (week 3, in parallel): Test layouts with a pseudolocale

Don't wait for translations to find layout problems. Android's documentation describes pseudolocales as locales designed to simulate characteristics of languages that cause UI and layout problems, created by automatic translations that stay readable in English. Text that doesn't change in the pseudolocale reveals strings still hard-coded in the source. Android documents a pseudolocale for longer text and one for right-to-left layouts.

Run the app in a pseudolocale and look for:

  • text cut off or overflowing buttons (German words are often long);
  • hard-coded strings that didn't change;
  • layouts that break with longer text;
  • dates, numbers and currencies formatted by hand rather than by locale.

Fix these before the translator's work arrives.

Phase 5 (weeks 4–5): Translate

  • Send the cleaned files, comments, limits, screenshots and glossary to your translator or translation service.
  • If you use machine translation for a first draft, have a native speaker review it in context.
  • Keep translations in the same file formats, so nothing is pasted by hand.

Phase 6 (week 6): Review in the running app

Translation in a spreadsheet and translation on screen are different things.

  • A native speaker uses the app in the new language for every main flow: onboarding, core task, payment, settings, errors.
  • Check plurals with 0, 1, 2 and larger numbers.
  • Check push notifications and emails.
  • Note fixes directly against string keys.

Phase 7: Release and keep it current

  • Translate app store listings and screenshots for the new language.
  • Add a step to your development process: new or changed strings go to translation before release, not after.
  • Decide what happens when a translation is missing (usually fall back to English) and make sure it's visible in testing.

Mistakes that cost the most time

  • Translating before strings are clean, then paying to retranslate after code changes.
  • Reusing one string in two places because the English happens to match ("Open" as a verb on one screen and an adjective on another). Translations often differ; give each its own key.
  • Concatenating translated fragments in code, which produces broken grammar in German and many other languages.
  • No owner for strings. Someone on the team should approve new user-facing text before it ships, so translators aren't chasing a moving target.

FAQ

Can we just use machine translation?

As a first draft, often. For anything customer-facing, a native speaker should review it in the app, especially tone and terminology.

How much longer is German text?

It varies by string, but German often needs more space than English. Design buttons and labels with room to grow, and test with a pseudolocale.

Should web and mobile share translations?

Sharing a glossary and key terms helps consistency. Sharing files is possible with tooling, but platform formats differ.

When should we start localisation?

Extracting strings early is cheap; retrofitting later is expensive. Even if you launch in one language, keep text out of the code from day one.

If your app needs a second language and the strings are still scattered through the code, tell us which platforms you're on and we'll outline the clean-up and translation steps.

Sources

WhatsAppLet’s talk