VIEW THIS AS

Auto mode follows the Route Engine until you choose a viewpoint.

YOU ARE HERE

ROUTE CHECK

CONNECTED TO

WHAT NEXT

Use the canonical route for this room, or HELP if you are unsure.

Top Ways to Translate Correctly | Android XML String Resources, Plurals and Placeholders

To translate Android strings.xml correctly, preserve the resource keys and runtime placeholders while rewriting only the user-facing language. Android app localisation is not a simple task of replacing English words inside an XML file. The safe process starts with identifying what Android will parse, which resource variant the device will choose, and which variable a message expects at runtime. This guide explains Android string resources, quantity plurals, translated string arrays, escaping, regional resource directories and mobile localisation QA with concrete examples that developers, students and translators can repeat.

An Android translation can read beautifully in a spreadsheet yet fail in the application: a placeholder can display as literal text, a count can select the wrong plural category, an apostrophe can be consumed by the resource parser, or a string can vanish because it was placed under an incorrect resource qualifier. A reliable translator therefore works on two layers at once. One layer is human meaning, register and clarity; the other is the exact Android resource contract that makes the sentence appear at the right moment. The objective here is to make both layers visible and testable.

What you need to know first

  • Treat Android app string resources and locale-specific XML as a language-and-software contract, not a stand-alone word list.
  • Diagnose resource identity, dynamic arguments, grammatical choice and device behaviour separately.
  • Use a staged workflow: inventory, context, translation, structural checks, runtime tests and release audit.
  • Compare concrete examples, failure modes and independently reproducible test results before approval.
  • Preserve application meaning, including negations, timing, permissions, money and user choices.
  • Practise on a small sample first; extend only when the sample passes.

The visible problem: why a fluent translation can still fail

The common failure is to treat a resource entry as ordinary prose. A translator sees ‘You have %1$d pending tasks’ and edits the percent expression or moves a line into the wrong XML element. The translated paragraph may look grammatical in an editor but break when Kotlin or Java formats it. Another failure arises when an English singular/plural pair is copied into a language whose quantity rules differ. The repair is to identify resource identity, typed variables, locale selection, grammatical categories and rendered experience separately. Keep the source resource as a contract, document each non-translatable element, and test the compiled application instead of approving only the text file.

The first diagnostic question is not “does the sentence sound natural?” but “what contract does the application expect this string to satisfy?” A string may identify a code key, interpolate a count, select a grammatical variant, carry a clickable instruction or announce an accessibility event. These roles are different. A correction that improves one role may silently damage another. For Android app string resources and locale-specific XML, a careful team should be able to point to the source location, the condition that displays the text, the proposed target wording, the protected characters and a repeatable test. Without those observations, approval remains a guess.

The second diagnostic question concerns the reader. Who will see this screen, what do they already know and what action will they take on the strength of its wording? A warning must retain the original danger or restriction. A preference label must identify the available choice. A payment message must distinguish a request from a completed transaction. Translate faithfully before trying to make language shorter, warmer or more promotional. Only then adjust style and screen fit within the original meaning.

First principles: eight distinctions that prevent error

1. A string resource is an interface, not an isolated sentence

The XML resource has an identifier consumed by code, optional translation flags, and text shown to people. Confusing these layers causes a technically valid translation to become unreachable.

Record the key and its code use before changing a value. Compare actual UI screenshots to the source message; the same English word can be a button, a status or an instruction.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

2. Plural categories are grammar categories

Android supports category names zero, one, two, few, many and other, but the categories actually selected depend on the target locale. The label one is not a promise that only the number 1 selects it.

Use the target language’s required forms and test a table of numbers through Android’s resource selection, rather than assuming English has supplied all necessary branches.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

3. The formatting argument has a type and order

A percent-format placeholder can carry positional information and a conversion type. The language may need to reorder arguments without changing their values.

Maintain a placeholder inventory with argument index, expected type and example runtime value. Reject translations where a count is converted into a name or a literal percent sign is lost.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

4. Escaping happens in more than one layer

The same visible text travels through XML parsing and Android resource handling. The apostrophe, ampersand, markup and whitespace therefore need distinct treatment.

Separate XML syntax from Android string syntax. Validate by compiling a small resource and reading back the rendered text, not merely by visually inspecting source XML.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

5. Locale matching is the system’s job

Resource directories and Android’s locale negotiation determine the selected string. A translator cannot fix a missing regional variant merely by adding a longer sentence.

Map required languages and regions to the actual project resources, test the device’s selected locale, and record when a base or fallback language intentionally appears.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

6. Not everything should be translated

Identifiers, machine values, product codes, markup and variables may need exact preservation even when they occur inside a sentence.

Mark protected tokens explicitly and explain their purpose. An automatically protected token still needs a human check for visual spacing and natural word order around it.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

7. Screen context changes grammar

A text unit used as a navigation tab has different constraints from the same words appearing in a detailed notification. A grammatical noun can require additional context in another language.

Review the resource’s screen, state, audience and neighbouring strings. If one key is reused for incompatible contexts, ask developers to split the resource rather than force one universal translation.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

8. Release proof is stronger than editor confidence

A clean translation file does not prove device behaviour. Font coverage, clipping, voice accessibility and dynamic values can fail only when the app runs.

Build, test and collect screenshots in representative languages, small screens and accessibility settings. Record the tested build and the exact locale so later changes can be compared.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

A repeatable twelve-stage translation method

The following sequence is designed for Android app string resources and locale-specific XML. It moves deliberately from discovery to evidence. Do not collapse linguistic and engineering acceptance into a single checkbox: people can review naturalness while automated tests inspect keys, formatting and resource loading. The method also prevents premature large-scale translation. First prove a small representative set, especially one count-driven message, one value with special characters and one ambiguous screen label. Then proceed to the remainder of the catalogue.

Stage 1: Inventory resources

List strings, plurals and string arrays, including their resource names and source files.

Preserve the mapping from each translated value to its original code reference.

The deliverable for this stage is a reviewable source-to-target inventory, not a loose translation document. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 2: Record context

Open the screens or code locations that actually display each string.

Annotate the intended user action, whether the message is a button, title or alert, and the maximum practical space.

The deliverable for this stage is a context note beside every ambiguous short entry. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 3: Identify protected syntax

Extract format specifiers, XML entities, resource references and intentional markup before translating.

Flag tokens such as %1$s, %2$d, @string/name and literal identifiers for a non-linguistic verification step.

The deliverable for this stage is a token ledger and a pass/fail rule for each token. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 4: Mark translatability

Inspect translatable flags and distinguish UI copy from keys, SKU identifiers or protocol strings.

Do not turn a translatable=false resource into a translation without engineering approval, and do not assume every visible English word must remain English.

The deliverable for this stage is a documented inclusion and exclusion list. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 5: Plan locale variants

Match requested target languages to res/values language and region directories used by the app.

Prefer the locale structure supported by the project rather than creating attractive but unrecognised folder names.

The deliverable for this stage is a target-locale matrix with explicit fallback expectations. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 6: Translate sentence meaning

Draft target text in the screen’s context, keeping commands, permissions and consequences exact.

Avoid both word-for-word calques and unsupported promises, especially in safety, consent and payment messages.

The deliverable for this stage is a fluent candidate tied to the original intended action. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 7: Rebuild placeholders

Move numbered placeholders only when required by grammar; preserve types and indices.

Where positional formatting is used, verify each field in a real or mocked call with deliberately different sample values.

The deliverable for this stage is a placeholder parity report that shows input and output arguments. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 8: Handle quantities

Review every plurals collection and supply the forms required by the selected locale.

Test not just zero, one and two, but values such as 11, 21, 101 and decimal values where the API and product design permit.

The deliverable for this stage is an observed plural-selection table. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 9: Validate parser rules

Check XML validity, apostrophes, quotations, line breaks and escaped characters with the Android build.

Do not rely on a third-party text editor’s preview as evidence that Android will display the same sequence.

The deliverable for this stage is a clean build and a rendered-character comparison. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 10: Test interface fit

Run translated layouts on small and large devices, with large text, right-to-left content and screen readers as applicable.

Inspect truncation, button meaning, alignment, tap-target context and whether an error is understandable in isolation.

The deliverable for this stage is screenshots and accessibility notes for risky interfaces. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 11: Review change impact

Compare changed source strings to translations and determine which ones require retranslation.

Avoid silently reusing an older approved translation when the source has changed from an option into a mandatory instruction.

The deliverable for this stage is a change log with explicit approval decisions. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 12: Release and monitor

Publish only after engineering and linguistic checks both pass, then watch user reports and telemetry for language-specific defects.

Track defects by key, locale, build and reproduction steps rather than the vague label ‘bad translation’.

The deliverable for this stage is a traceable release record and an accessible correction path. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Twenty worked examples: from source text to reliable output

Each case presents an observable input, a tempting but unsafe edit, the correct direction of repair and a way to prove the repair. Examples are deliberately varied: some are grammar problems, some are encoding or syntax problems, some are resource-resolution problems, and others are real interface safety problems. A professional review should be able to classify the case before applying its solution. The examples are teaching scenarios, not a substitute for running the project’s own build and locale tests.

Worked example 1: Button label reused as a noun

Start with this situation: The source key ‘open’ appears both on a button and in a sentence about an open case. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: One translation forces a verb into the adjectival slot and misleads users. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Split contexts or keys and choose a target verb for the button and an adjective for the case state. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Both usages read naturally on their actual screens. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 2: Two typed placeholders

Start with this situation: The source shows ‘%1$s has %2$d messages’. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Reordering words accidentally changes the person-name placeholder into a number. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Keep %1$s attached to the name and %2$d to the count, even if their positions shift. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Test with ‘Amina’ and ’47’ to expose argument swaps. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 3: Plural form selection

Start with this situation: An Android plurals resource covers one and other for a count. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The target language needs other grammatical categories, but only English categories were copied. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Provide categories appropriate to the locale and let Android select them by number. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Run 0, 1, 2, 3, 5, 11, 21 and 101 through the actual app. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 4: Selecting versus formatting quantity

Start with this situation: A Compose screen calls pluralStringResource with a number. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Only the plural-selection count was passed; %d appears unfilled in the displayed sentence. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Pass the relevant formatting argument when the chosen string contains a numeric placeholder. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Confirm the chosen plural and printed numeric value match. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 5: Apostrophes in UI copy

Start with this situation: A string contains ‘Don’t disconnect’. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The translator changes punctuation without considering Android string escaping. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Use the quoting or escape form accepted by Android resources and check rendered output. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Display the text on a device and compare the intended apostrophe. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 6: XML ampersand

Start with this situation: The text is ‘Terms & Conditions’. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: A raw ampersand is inserted into XML and parsing fails. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Encode XML-reserved characters appropriately in the resource source. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Compile and confirm a single ampersand appears on the screen. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 7: Escaped percentage

Start with this situation: A reward message contains a numeric percent sign. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The percent character is mistaken for a formatting marker or removed. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Distinguish a literal percent display from printf-format syntax and preserve the correct form. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Test the label with a sample value and inspect build warnings. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 8: String array ordering

Start with this situation: A settings menu displays a string-array of three choices. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The translated list is reordered while code still uses fixed positions. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Translate individual entries without changing their identity or order, unless the software explicitly supports sorting. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Select each option and confirm that it triggers the expected setting. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 9: Non-translatable resource

Start with this situation: An API-related key is marked non-translatable in the resources. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: An editor imports it as human copy and changes the machine value. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Exclude the value from linguistic changes and document its technical purpose. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Compare the packaged resource or project config to the protected source. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 10: Regional spelling

Start with this situation: Portuguese text needs a Brazil-specific interface label. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: A generic or Portugal-specific resource is silently shown in Brazil. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Add an approved regional variant according to Android’s resource qualifier rules. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Set the device to Portuguese (Brazil) and confirm the selected wording. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 11: Truncated notification

Start with this situation: A notification includes a long translated account status. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Translation is approved in a spreadsheet but cut off at narrow device width. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Keep the essential status or required action early while retaining its actual meaning. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Check real notifications in compact and expanded states. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 12: Consent permission

Start with this situation: An Android dialog asks to enable location for one feature. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The translation implies permanent tracking or claims that permission has already been granted. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Keep requesting, granting and active tracking as separate states. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Test before and after permission is granted. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 13: HTML-like formatting

Start with this situation: A string contains intended emphasis and a link. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Tagging and escaped entities are altered, causing markup to show literally or break. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Preserve only supported markup and validate the app’s actual rendering path. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Open the link and verify accessibility order. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 14: Right-to-left name

Start with this situation: An Arabic UI inserts an English product name into a sentence. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Punctuation jumps around the embedded name and the sentence appears reversed. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Apply appropriate bidi handling in the UI layer and review the translated sentence in context. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Test with Arabic text, Latin names and both left-to-right and right-to-left digits. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 15: Pseudo-localisation

Start with this situation: A tester enables Android pseudolocales. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The team mistakes a pseudo-language’s exaggerated accents or length for a defective translation. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Use pseudolocales to expose clipping and hard-coded strings, not to judge real grammatical quality. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Follow with testing in at least one actual target language. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 16: Empty fallback

Start with this situation: A new locale lacks a translation for one resource. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The app crashes or displays an unexpected empty value because the default resource is missing. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Maintain complete default resources and document the expected fallback behaviour. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Test a locale with an intentionally missing noncritical translation. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 17: Accessibility announcement

Start with this situation: An icon has a contentDescription resource. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The visual label is translated but the accessibility string is left in the source language. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Include content descriptions and spoken prompts in the same review as visible UI. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Use TalkBack and listen for coherent language and action. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 18: Payment confirmation

Start with this situation: The source says ‘Payment submitted, awaiting confirmation’. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Translation changes an intermediate status to ‘Payment complete’. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Preserve the difference between submitted, authorised, settled and failed states. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Test messages against realistic payment state fixtures. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 19: Source text changed

Start with this situation: The English label changes from ‘Remove’ to ‘Archive’. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: An older target translation still indicates deletion. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Mark the changed key for semantic re-review despite the unchanged identifier. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Check the displayed action in a test build. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 20: Whitespace or line breaks

Start with this situation: A multi-line instruction needs a clear order of steps. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Inserting unnecessary line breaks makes the warning’s condition look unrelated. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Use explicit breaks only where content or layout supports them, not as a workaround for translation length. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Render across phone sizes and increased font settings. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Twelve failure modes and how to diagnose them

A failure-mode catalogue is useful because an apparent spelling mistake can actually come from missing context, encoding, wrong resource resolution or a stale build. Diagnose the mechanism before replacing the words. Each entry below identifies an observable symptom, the most economical correction and an acceptance test. Keep these records attached to the product’s review process: they are more useful than a generic demand to ‘check the translation carefully’.

Failure 1: Keys mistaken for content

Symptom: A translated resource is unreachable or another screen shows the wrong message. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Restore stable identifiers and check references in code and compiled resources. The proof is: A source-target diff shows identical keys. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 2: Assumed English plurals

Symptom: Specific numbers sound ungrammatical in the target language. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Use locale-driven quantity categories rather than copying one/other blindly. The proof is: A count matrix covers exceptional numbers. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 3: Format specifier corruption

Symptom: Names, numbers or dates are swapped or a formatting exception appears. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Preserve indexed placeholders and compatible types. The proof is: A formatting test uses distinct typed values. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 4: Incomplete defaults

Symptom: A rare locale or missing translation causes broken fallback. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Ensure default resources contain all referenced names. The proof is: The app runs under an intentionally unsupported locale. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 5: Bad resource escaping

Symptom: A build error or literal backslash, entity or quote reaches the UI. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Verify both XML and Android-specific string syntax. The proof is: A compiled resource shows intended punctuation. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 6: Translation of machine tokens

Symptom: An internal identifier, address or code becomes unusable. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Protect non-linguistic substrings at extraction time. The proof is: Automated parity checks reject changed tokens. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 7: Missing screen context

Symptom: A noun is used where an imperative is required. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Require screenshots and disambiguating comments. The proof is: A reviewer verifies all contexts for duplicated source strings. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 8: Hard-coded English

Symptom: Most interface text is translated but a warning remains English. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Find text outside resource files and add it to normal localisation review. The proof is: Pseudo-localisation and UI crawling reveal hard-coded text. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 9: Unreviewed accessibility

Symptom: TalkBack reads mixed languages or ambiguous controls. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Translate content descriptions and test spoken usage. The proof is: A screen reader test covers critical flows. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 10: Unbounded length

Symptom: Buttons clip or overlap at large text scale. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Rewrite naturally while preserving core actions and allow responsive layout. The proof is: Screenshots pass with larger font settings. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 11: Misleading status language

Symptom: A temporary or requested state is presented as final. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Translate status transitions against a source-state table. The proof is: Each state fixture displays a distinct accurate message. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 12: Untested regional fallback

Symptom: A user sees unexpected vocabulary despite a locale-specific catalogue. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Inspect Android locale matching and actual resource packaging. The proof is: Device language and chosen resource are logged together. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Practice and transfer: ten checks learners can perform

These exercises are designed to transfer beyond the examples. Attempt each without looking at the proposed check, explain the rule you used and show independent evidence. Do not score a task as solved because the text ‘looks correct’ in its source file. The end condition is a reasoned translation and a visible result in the appropriate parser, build or application. A teacher can turn the exercises into paired reviews: one person checks language and another checks the technical contract.

Practice 1: Translate a warning with %1$s and %2$d

Task: Write a warning that preserves the name and number roles even when target word order changes. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Prove the result using a distinct example name and count. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 2: Audit a five-entry string array

Task: Preserve index-to-action identity for every option while making each label natural. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Tap every translated option in a test app. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 3: Design a plural test sheet

Task: Choose representative counts for your locale including edge cases around tens and hundreds. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Document the category actually chosen instead of predicting it from English. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 4: Review an apostrophe and ampersand

Task: Construct a resource entry that includes both without breaking XML or Android parsing. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Compile and compare displayed punctuation. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 5: Check a Portuguese (Brazil) variant

Task: Explain which resource file should own region-specific copy and what should happen otherwise. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Switch device locale and document observed fallback. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 6: Test a payment-state sequence

Task: Write distinct labels for pending, authorised, settled and failed. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Confirm no translation promises completion prematurely. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 7: Find hard-coded text

Task: Run the app in a pseudolocale and locate an English fragment that escaped extraction. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: File a defect with screen, key and screenshot. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 8: Audit a TalkBack label

Task: Translate an icon’s content description so it communicates action, not merely appearance. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Listen to the control with a screen reader. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 9: Check a long translated button

Task: Compare narrow-screen output at larger text sizes without deleting a necessary negation. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Record both language quality and layout defects. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 10: Update a changed source string

Task: Treat ‘Delete account’ becoming ‘Deactivate account’ as a semantic change. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Re-review the target rather than trusting a stable resource key. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Frequently asked questions

Should translators edit XML keys?

Normally no. Keys are referenced by code, so changing one may break lookup. Translate values and let developers approve identifier changes.

For Android app string resources and locale-specific XML, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

Does Android select all plural categories in every language?

No. The locale’s grammatical rules determine selected categories. A resource may support category names that are unused for a particular language.

For Android app string resources and locale-specific XML, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

Why are placeholders numbered?

Numbering allows languages to reorder inserted arguments while keeping the intended name, count or other value attached to the correct position.

For Android app string resources and locale-specific XML, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

Can I use machine translation directly in strings.xml?

It can produce a draft, but every variable, state, locale distinction and action must be reviewed and tested. Natural-looking output is not evidence of runtime safety.

For Android app string resources and locale-specific XML, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

What does translatable=false mean?

It indicates a resource should not be included in translation. Do not override the project’s declaration casually; ask why the value is protected.

For Android app string resources and locale-specific XML, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

Is translating every screen enough?

No. Notifications, accessibility descriptions, rare error messages and region-specific fallbacks can remain untested.

For Android app string resources and locale-specific XML, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

Can I force a zero category to display at zero?

Do not rely on zero behaving as a special phrase in every locale; the platform chooses categories according to grammar. Use product logic when the intended zero message is semantically special.

For Android app string resources and locale-specific XML, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

What is the difference between localisation and translation?

Translation supplies the target wording; localisation also includes locale selection, numbers, dates, layout, testing and the application’s end-to-end behaviour.

For Android app string resources and locale-specific XML, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

What is a useful small-team release gate?

Require a clean build, token parity, representative count tests, device screenshots and approval of high-risk consent and payment states.

For Android app string resources and locale-specific XML, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

Which related guide should I read next?

Use the JSON resource guide for stable data keys, the CLDR plural guide for grammatical category theory and this page for Android-specific resource behaviour.

For Android app string resources and locale-specific XML, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

A practical review sheet for parents, students and working translators

A beginner need not learn every detail of a software framework before doing useful translation work. Begin with ten messages. For each, write the source, intended user meaning, target version, context, protected symbols, a sample dynamic value and the on-screen result. Ask another person to test the message without being told what it is supposed to say. If their interpretation differs from the source action, discuss the mismatch. This is a language lesson as well as an engineering lesson: words are useful only when they convey the right distinction to the reader.

For classroom transfer, select a short instruction that uses a condition, a negative and a number. Translate it into another language, then back into a plain-language paraphrase of the target. Check whether the condition and the negative survived. Next compare two messages that differ in just one state: requested versus completed, open versus closed, allowed versus required. A small change of meaning can be more consequential than a large spelling error. The same habit supports reading comprehension, written precision and responsible communication.

For production, prioritise defects by consequences. A clipped decorative caption may be lower risk than an incorrect cancellation warning. An altered error code can block diagnosis; an incorrect consent phrase can affect what a person believes they have permitted. Rate issues by user impact, not the number of words changed. Agree on a release gate, keep the original source available and make targeted corrections rather than rewriting the entire translation when one mechanism fails.

Authoritative documentation and further learning

Platform documentation is authoritative for software syntax and runtime behaviour, but it is not a substitute for a native-language reviewer, product-state evidence or accessibility testing. For grammatical choices, examine actual target-language usage and distinguish an illustrative translation from an officially approved term. When tools or platform versions change, verify the behaviour against the project that will ship.

Continue with the translation series index; the Vocabulary Learning Hub; the CLDR plural rules guide; the JSON resource bundle guide; the Fluent localisation guide; the XLIFF 2.1 translation guide. For the adjacent English-learning route, follow the ‘How English Works’ pathways linked from the Vocabulary Learning Hub. These routes serve different questions: word meaning, grammatical category, resource-file mechanics and runtime assurance.

Closing decision: is the translation ready?

A translation of Android app string resources and locale-specific XML is ready only when the target sentence preserves the intended user action and the system displays it under the correct conditions. Require evidence for the high-risk branches, not just a plausible sentence. Start with the visible problem, return to first principles, apply the repeatable method, test edge cases and document where the remaining uncertainty lies. When both language and application behaviour pass, the translation becomes a dependable part of the user experience rather than a fragile layer of text.