OnlineDocTranslatorGuides

Running your practice

Application Localization: The Translator's and Agency's Guide

Application localization is the end-to-end process of adapting an app's strings, UI, formats, and cultural references for a specific locale — here is how

Application localization is the production discipline this guide treats from the translator's and agency's seat — the string file open in the editor, the translation memory feeding leverage, the character budget printed next to each segment, and the LQA scorecard that signs off the release. The pages that rank for this term speak to buyers; this one speaks to the people doing the work.

What is application localization from the translator's side of the desk?

Application localization is the end-to-end adaptation of an app's strings, UI layout, media, number and date formats, and cultural references for one target locale, delivered by translators and reviewers working inside resource files, translation memory, and a staging build the developer merges back into the repo. The translator's desk holds five artifacts — resource bundle, TM, term base, style guide, and a pseudo-loc or staging build — not a Word document.

For the canonical cross-discipline definition, see our guide on what localisation means and how professionals define it. Four facts frame the seat:

  • The deliverable is a locale-stamped resource file, not prose.
  • The source is externalized by the dev team before the translator touches it.
  • Context arrives as screenshots, character limits, and segment IDs.
  • Quality is scored per 1000 words against a weighted rubric at release.

What does an application localization project actually contain?

An application localization project contains five artifacts the translator inspects before quoting: the extracted resource bundle, the project translation memory, the client term base, the locale style guide, and the pseudo-localization or staging build used for in-context review.

ArtifactWhat to check before quoting
Resource bundle (.xliff, .json, .strings, strings.xml)Segment count, placeholder density, character limits attached, context fields populated
Translation memoryLeverage report: ICE, 100%, 95–99%, 85–94%, no match — drives the discount schedule
Term baseEntries per locale, forbidden terms, enforcement set to hard-fail in the editor
Style guideRegister, address form (tú/usted), punctuation, number and date conventions
Pseudo-loc or staging buildTruncation hotspots, hard-coded strings, RTL readiness, encoding sanity

How does application localization differ from software localization and website localization?

Application localization is the subset of software localization scoped to a shipping end-user app — iOS, Android, desktop, web app — while website localization covers browser-rendered marketing and content sites, and broader software localization also covers back-office, embedded, and SDK layers. For the sibling discipline, see Website Localization: What Translators and Agencies Actually Do on the Project.

  • Application: compiled or packaged binary, resource bundles, store metadata, release train.
  • Website: CMS strings, SEO metadata, continuous publishing, no store review.
  • Software (broad): back-office consoles, SDK docs, embedded firmware strings, EULAs.

How does UX writing and UI copy affect the translator's brief?

UX copy carries strict character limits and tone constraints that shape every segment decision. Button labels, error messages, and onboarding tooltips must preserve the UX intent — a 12-character English CTA cannot become a 24-character German phrase on an iOS primary button. Translators treat each segment as a UI component, not a sentence.

How it works

How does the application localization process run from brief to release?

1

What does the internationalization (i18n) handoff look like?

The internationalization handoff is the point where developers deliver a build whose strings, dates, numbers, and layouts are externalized and locale-ready, so translators can work without touching code. For the engineering-side deep dive, see Internationalization (i18n) Explained for Language Professionals, and for a framework example, see How to Add i18n to an Astro Site.

Internationalization is the prerequisite that makes localization possible — it is the engineering step that externalizes strings and locale-dependent code so translators can work without touching source. Four handoff artifacts tell the translator whether i18n is complete:

  • Resource files with no concatenated sentences.
  • Date, number, and currency rendering via locale APIs, not hard-coded.
  • Plural handling via ICU MessageFormat or platform equivalent.
  • Layout that reflows for text expansion and RTL mirroring.

2

How are strings extracted and delivered to the translator?

Strings are extracted into locale resource files and delivered as a CAT or TMS job with source context, screenshots, and character limits attached per segment. The common formats are .strings and .stringsdict on iOS, strings.xml on Android, .resx on .NET, .properties and .po on cross-platform back ends, and .json or .xliff as the TMS interchange format. For framework-specific pipelines see React i18n: How Translators Fit Into a React Localization Pipeline and JavaScript Localization Libraries Compared for Translation Professionals.

3

Where does pseudo-localization fit in the workflow?

Pseudo-localization fits between extraction and translation as a dev-side stress test that inflates strings and swaps characters to expose hard-coded text, truncated UI, and encoding bugs before any human translation money is spent. Our dedicated reference, Pseudo Localization: What Translators Need to Know About i18n Test Builds, covers the test-build mechanics in full — this page treats it as a gate, not a tutorial.

4

What happens during in-context review on the staging build?

During in-context review the translator or reviewer opens the staging build with locale forced on, walks every screen, and files per-string issues against the segment ID in the TMS. Four issue types dominate the ticket queue:

  • Truncation on primary CTAs, tab bars, and form labels.
  • Wrong register — formal where informal was briefed, or vice versa.
  • Placeholder drift that compiles but renders a raw token.
  • Misleading icon pairing where the translated label contradicts the glyph.

5

What does linguistic quality assurance (LQA) check at release?

Linguistic quality assurance checks five categories at release — accuracy, terminology, style, locale conventions, and functional integrity — scored against a weighted rubric that produces a per-1000-word error count.

LQA categoryWeightWhat it catches
Accuracy30%Mistranslation, omission, addition against source
Terminology20%Term base violations, inconsistent brand terms
Style15%Register, voice, style guide drift
Locale conventions15%Dates, numbers, currency, address format, punctuation
Functional integrity20%Placeholder, tag, plural branch, character-limit breakage

Agencies quote a pass rate of under 10 errors per 1000 words at major/critical severity. Regulated verticals tighten the bar — see What Financial Localization Requires Beyond Standard Translation and How Pharma Localization Works and What It Demands from Translators for sector-specific adjustments to the locale-conventions row.

About

What should translators know about resource files, placeholders, and ICU plurals?

Translators handling application localization work inside locale resource files that carry placeholders, plural rules, and markup — breaking any of them crashes the build. Five integrity checks belong in every QA pass:

  1. Placeholder presence — every {name}, %s, %@ in source appears in target.
  2. Positional order — %1$s and %2$s indices preserved or correctly reordered.
  3. Plural branch coverage — every CLDR category required by the target language filled.
  4. HTML and XML tag balance — <b>…</b>, <link>…</link> opened and closed.
  5. Escape consistency — \" and \n handled per the file format's rules.

These five breakages drive roughly 80% of post-handoff bug tickets.

Which resource file formats appear most often in app projects?

The resource file formats translators see most often are platform-mapped and tool-mapped per project:

Platform / roleFile formatNotes
iOS.strings, .stringsdictUTF-16 by default; .stringsdict carries plural rules
Androidstrings.xmlPlural tags, escape rules for apostrophes
.NET.resxXML with name/value pairs and comments
Cross-platform back end.po, .properties, .jsonGettext, Java properties, JSON key-value trees
TMS interchange.xliff, .tmxRound-trips the segment plus metadata

How do placeholders behave in iOS, Android, and ICU syntax?

Placeholders behave differently per platform: iOS uses printf-style %@ and %1$@ positional tokens, Android uses %s with explicit indices, and ICU MessageFormat uses named {variables} with select and plural branches. Mixing syntaxes in a translation unit breaks compile. For iOS specifically, see SwiftUI Localization: A Practical Guide for App Translators.

How are ICU plurals and gender branches translated correctly?

ICU plurals and gender branches are translated by filling every CLDR category the target language requires, not by copying the English singular/plural pair. The ICU MessageFormat syntax uses named {variable} placeholders with select and plural branches. Named example counts:

  • English — 2 forms: one, other.
  • Russian — 4 forms: one, few, many, other.
  • Polish — 3 forms: one, few, many.
  • Arabic — 6 forms: zero, one, two, few, many, other.
  • Chinese and Japanese — 1 form: other.

Pricing

How much does text expansion affect application localization layout?

Text expansion changes app layout by target language. German strings grow about 35% over English, Russian 30%, Spanish 25%, French 20%, while Chinese and Japanese contract about 40%. Translators quote character budgets per segment to protect buttons, tabs, and iOS navigation bars from truncation. For UI-specific depth, see UI Localization: Constraints, Pitfalls, and Best Practices.

Target languageExpansion vs EnglishCommon UI pain points
German+35%Tab bars, primary CTA buttons, form field labels
Russian+30%Toasts, iOS navigation bar titles, menu items
Spanish+25%Buttons, onboarding tooltips
French+20%Buttons, settings labels
Chinese (Simplified)-40%Visual balance, line-height tuning — see Chinese Localization: What Makes It Harder Than Most Projects

Which UI elements break first when strings expand?

The UI elements that break first are iOS tab-bar labels, Android bottom navigation, primary CTA buttons, form field labels, and single-line toast messages. All five carry hard character limits a translator respects per segment, and all five surface in pseudo-loc before any real translation ships.

How do right-to-left languages change the layout brief?

Right-to-left languages like Arabic and Hebrew mirror the layout: navigation flips, icon chirality reverses, number sequences stay left-to-right inside RTL paragraphs. Translators flag any UI element whose meaning depends on direction — a back arrow, a progress bar, a chevron on a list row — so the dev team mirrors or swaps the asset per locale.

Get a quote

When does a project move from waterfall to continuous application localization?

A project moves to continuous 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. For the delivery model, see How Continuous Localisation Works and When to Offer It, and for experiment-driven string flow, see How Pendo Localization Works and What Translators Need to Know.

  1. Release cadence under two weeks.
  2. Over 500 new or changed strings per sprint.
  3. More than six active target locales.
  4. In-app experimentation generating strings between releases.

What changes operationally in a continuous localization setup?

In a continuous localization setup, strings flow from the repo to the TMS automatically via a connector, translators work on micro-jobs sized in minutes, and the agency bills on retained capacity or per-word with an SLA on turnaround, not on one-off POs. The PM role shifts from job dispatch to exception handling and capacity planning.

How do translation memory and term base behave under continuous flow?

Under continuous flow the translation memory updates after every merged segment and the term base is enforced as a hard check in the editor. Translation memory stores approved segments per client and locale and drives leverage percentages that discount per-word pricing. The term base locks brand terminology per locale and fails the segment at save when violated. Translators see leverage and terminology status in real time instead of in a weekly export.

What does app store metadata localization require from translators?

App store metadata localization requires the translator to deliver eight fields per locale, each with its own length limit and ASO constraint. For the website SEO sibling discipline, see How to Apply SEO Principles When Localizing a Website.

FieldiOS limitGoogle Play limit
Title30 characters50 characters
Subtitle30 characters—
Promotional text170 charactersShort description 80 chars
Keywords100 characters— (ranks on full description)
Full description4000 characters4000 characters
"What's New"4000 characters500 characters
Screenshot captionsPer-image overlayPer-image overlay
In-app purchase display names30 characters55 characters

Promotional text and screenshot captions often cross into transcreation — see Transcreation Defined: How It Differs from Translation for the rate and workflow difference. For the marketing-lane framing, see What Localization in Marketing Means — and How to Deliver It.

How do iOS App Store and Google Play metadata requirements differ?

The iOS App Store exposes a dedicated keywords field capped at 100 characters while Google Play has no keywords field and ranks the full description instead. Translators adapt the same source brief into two different ASO shapes per locale — tight keyword packing for iOS, keyword-density prose for Play.

How are keywords localized without machine-translating them?

Keywords are localized by researching the target-locale search terms with store analytics or an ASO tool, then selecting the 100-character set that matches intent. This step is distinct from translating the English keyword list and is billed by the hour, not by the word.

Pricing

How do agencies price application localization work?

Agencies price application localization on a per-source-word base rate ($0.10–$0.25 USD for European targets, higher for low-resource locales) plus line items for placeholder-dense segments, in-context review hours, LQA passes, pseudo-loc rebuilds, and ASO metadata. Continuous retainers replace per-job pricing above a defined string volume.

What line items belong on an application localization quote?

The line items that belong on an application localization quote are eight, priced per locale:

Line itemUnitTypical US agency range
TranslationPer source word$0.10–$0.25
ReviewPer source word$0.04–$0.08
In-context reviewPer hour$60–$120
LQAPer 1000 words$40–$90
Project management% of job10–15%
TMS connector setupFlat$300–$1,500 one-time
Pseudo-loc rebuildFlat per build$150–$500
ASO metadata per localeFlat$120–$350

Placeholder-dense segments carry a surcharge of 15–25% because the editor time per word rises sharply when every string carries two or more tokens. Adjacent application types — games, for instance — price differently; see How to Localise a Godot Game for Multiple Languages and How Video Game Localization Works and What Clients Expect.

How does machine translation post-editing (MTPE) change the rate card?

Machine translation post-editing changes the rate card by splitting the per-word rate into a lower raw-MT line and a human post-edit line, with the combined price typically 50–70% of full human translation when the engine quality and domain fit have been tested on the client's own strings first. MTPE on untested engines prices at full human rates because the editor rewrites rather than edits.

Get a quote

What are the common application localization pitfalls agencies see?

The common application localization pitfalls agencies see are five recurring failures: hard-coded strings missed by i18n, concatenated sentences that break grammar in target locales, context-free segments quoted at full rate, placeholder drift surviving to production, and ASO metadata translated without keyword research. For the dedicated anti-pattern treatment, see Bad Localization: What Goes Wrong and How to Avoid It.

How are concatenated strings handled when the dev team cannot refactor?

When the dev team cannot refactor concatenated strings, the translator flags each affected segment, requests a single-sentence rewrite in English, or negotiates per-locale rewording that preserves grammatical agreement. The translator never silently reorders the fragments — gender, case, and verb agreement collapse when a target language inflects differently from English.

What goes wrong when context is missing from the resource bundle?

When context is missing from the resource bundle, translators guess the register, part of speech, and screen placement — producing segments that compile but read wrong in-app. The downstream cost is LQA failure, bug tickets, and rework that exceeds the initial translation fee. The PM fix is to require a screenshot or developer comment on every segment before the job opens.

Which tools do translators and agencies use for application localization?

Translators and agencies use three tool categories: translation management systems (Crowdin, Phrase, Lokalise, Transifex, Smartling) that host the project, CAT editors (Trados Studio, memoQ, OmegaT, Wordfast) that host the translation work, and QA utilities (Xbench, Verifika, LQA scorecards) that gate release. For a Crowdin-specific drill-down, see How Translators and Agencies Work Inside Crowdin.

What does a TMS do that a CAT tool does not?

A TMS adds the project layer a CAT tool lacks: repo connectors, string lifecycle tracking, in-context editors, multi-translator assignment, pseudo-loc generation, and ASO metadata hosting. The CAT tool is the segment editor; the TMS is the production system around it.

  • TMS scope: repo sync, job routing, in-context, roles, analytics, store metadata.
  • CAT scope: segment, TM leverage, TB enforcement, QA checks, bilingual export.
  • QA utility scope: cross-file checks for terminology, placeholders, numbers, consistency.

Where does application localization sit inside the broader localization program?

Application localization sits as one of six delivery lanes inside a broader localization program: product app, website, marketing content, support knowledge base, legal and compliance documents, and in-product video. Each lane carries its own SLA, tooling, and reviewer pool, but all six share one term base and style guide per locale. For the program framing, see How Enterprise Localization Programs Are Structured and Run and Building a Localisation Strategy That Agencies Can Execute.

Sibling lanes and adjacent scopes translators are routinely moved across:

  • Website — Website Localization: What Translators and Agencies Actually Do on the Project.
  • E-commerce platforms — How Shopify Localization Works and What It Means for Your Agency, How Webflow Localization Works and What Translators Need to Know.
  • Marketing and content — Content Localisation: How to Adapt Material That Goes Beyond Text.
  • Services with no physical product — Localizing Services: What Changes When There's No Physical Product.

How is ROI measured on an application localization program?

ROI on an application localization program is measured against four metrics tracked per locale: install uplift, 7-day retention delta, average revenue per paying user, and support ticket deflection. The baseline is captured on the English-only build before the first locale ships. For the full reporting treatment, see How to Measure and Present the ROI of Localization Work.

Application localization costs $0.10–$0.25 per source word for European target locales on the translation line, plus review, in-context, LQA, PM, and ASO metadata line items. A 10,000-word app launching in five locales commonly lands between $8,000 and $20,000 for the first release, before continuous-localization retainers kick in.

Frequently asked questions

What does app localization mean?

App localization means adapting a software application's content, interface, and functionality so it feels native to a specific target locale — not just translating strings, but also formatting dates, currencies, plurals, and culturally sensitive imagery. For translators and agencies, this typically involves working with resource files (e.g., .strings, .xml, .json) exported by developers, translating UI strings within tight character limits, and returning files that slot directly back into the codebase. Certified translation teams may also need to handle in-app legal disclosures or terms of service that require formal certification alongside the standard linguistic work.

What is localization in apps?

Localization in apps is the end-to-end process of making a mobile or desktop application fully usable and culturally appropriate for a new language-market combination. It goes beyond UI string translation to include locale-specific number and date formatting, right-to-left layout support, app store listing copy, push notification text, and any regulated content (such as medical or legal disclaimers) that may require certified translation. For agencies producing certified translations, app localization projects often arrive as bundled file packages requiring both linguistic accuracy and format-exact file return so the developer can rebuild the app without reformatting.

What is the software localization process?

The software localization process typically follows five stages: content extraction, translation and adaptation, engineering/DTP, quality assurance, and delivery. Developers first export translatable strings into resource files; translators then work on those files — often inside a CAT tool or TMS — before the localized files are reintegrated and tested in-app. For certified translation contexts, an additional certification or notarization step is inserted after linguistic QA. Turnaround for a mid-sized app (5,000–20,000 words) typically runs one to three weeks depending on language pair, complexity, and whether certification is required.

How is localization different from translation?

Translation converts text from one language to another, while localization adapts the entire user experience — text, visuals, formats, and cultural references — so the product feels locally made. A translator renders words accurately; a localizer also adjusts idioms, resizes UI elements for text expansion (German can run 30–40% longer than English), converts units, and flags culturally inappropriate imagery. In certified translation production, the distinction matters because a certified translation guarantees linguistic accuracy of a specific source document, whereas localization is an iterative, engineering-adjacent workflow that rarely carries a single certification stamp over the whole product.

What does localization mean in software?

In software, localization (often abbreviated L10N) means configuring an application to display content correctly and culturally appropriately for a specific locale, identified by a language-region code such as fr-CA or zh-TW. This covers UI text, error messages, help documentation, date/time and number formats, currency symbols, keyboard input handling, and sometimes right-to-left text rendering. For translators delivering work into software pipelines, it also means respecting placeholder syntax (e.g., %s, {0}), character limits, and file encoding requirements so that translated strings integrate without breaking the build.

What does localization mean in simple terms?

In simple terms, localization means making a product feel like it was built for a specific country or language community — not just translated, but truly local. Think of it as the difference between a menu that says "USD 5.00" everywhere versus one that automatically shows "€5,00" in Germany with the correct decimal convention. For translation professionals, localization is the discipline that combines linguistic skill with technical file-handling so that apps, websites, and documents work correctly in every target market.

What is an example of localization?

A clear example of localization is a medical app originally built in US English being adapted for the Brazilian Portuguese market. The work involves translating all UI strings, converting date formats from MM/DD/YYYY to DD/MM/YYYY, replacing Fahrenheit references with Celsius, adjusting dosage units where relevant, and — for any patient-facing regulatory disclosures — producing certified translations accepted by Brazil's ANVISA. The app store listing copy and push notifications are also rewritten for Brazilian idiom, not just word-for-word translated from European Portuguese.

How much does localization cost?

App localization costs vary widely, but translators and agencies typically charge between $0.10 and $0.30 per source word for standard language pairs, with less common pairs or certified content running higher. A 10,000-word app might cost $1,000–$3,000 per language in translation alone, plus engineering, DTP, and QA fees that can add 20–50% to the total. Certified translation of specific in-app documents (terms of service, medical disclaimers) is usually priced per page or per document rather than per word, ranging from $25 to $100+ per page depending on complexity and jurisdiction.

What are the best practices for localizing software and products?

Key best practices include internationalizing the codebase before localization begins (separating hard-coded strings into resource files), providing translators with context through screenshots or a style guide, setting and enforcing character limits for UI strings, and running in-context QA on the live build rather than only on raw files. For certified translation elements within an app — such as legal terms or regulatory notices — agencies should maintain a clear audit trail linking the source document version to the certified output. Using translation memory and glossaries across projects cuts costs and ensures brand-term consistency over time.

How does localization work?

Localization works by separating content from code so that translatable text can be swapped out without rewriting the application logic. Developers export resource files (e.g., strings.xml for Android, Localizable.strings for iOS), hand them to translators or agencies, and then reintegrate the returned files for each target locale. Translators work on those files using CAT tools that display source and target side by side, flag repeated segments, and enforce glossaries. Quality assurance is then done both on the raw files (checking formatting tags and placeholders) and inside the running application (checking text display, truncation, and cultural fit).

How can I localize my iOS app?

To localize an iOS app, developers use Xcode's built-in localization workflow: marking UI strings with NSLocalizedString, exporting an XLIFF file per target language, sending those files to translators, and reimporting the translated XLIFF before building. As a translator or agency receiving iOS localization work, you'll most often handle XLIFF or .strings files, need to respect variable placeholders like %@ and %1$d, and work within character limits imposed by the UI. If any in-app content — such as privacy policies or medical disclaimers — requires certified translation, those should be scoped and delivered as a separate certified document alongside the standard localization files.

Related