How do you translate an SAP Mobile Development Kit app, configure i18n.properties files and make locale fallback work on actual mobile devices? This SAP MDK localization guide explains the Application.app Localization reference, BrandedSettings.json DefaultAppLanguage, language, script and region filenames, placeholder values, SetLanguage priority and practical Android and iOS testing.
SAP’s Mobile Services documentation describes MDK localization using a default .properties resource and corresponding language variants packaged with app metadata. It also documents an explicit language priority: app-defined selection first, iOS preferred app language when applicable, device language, application default and finally a hard-coded fallback. The details matter because a translated file on a developer’s computer is not necessarily the file the deployed app loads.
International field-service and enterprise mobile apps often contain work orders, inspection outcomes, deadlines and authorization controls. A translation should make those instructions understandable without changing a record ID, an amount, a unit or the true status of a request. This chapter connects precise configuration steps with the complete user experience, from initial language selection to error handling, offline work and a verified result.
Quick answer: the SAP MDK localization route
Provide a default i18n properties file in the metadata, point Application.app Localization at it, and add correctly named language, script or region variant files using the same base filename. Configure DefaultAppLanguage as appropriate, preserve key=value syntax and placeholder indices, and use supported localization references in metadata and rules. Test app-defined SetLanguage selection, iOS app preference, device language and fallback on installed builds, checking the actual server outcome behind each translated action.
Before you build: a practical MDK checklist
- Confirm the project is SAP Mobile Development Kit.
- Identify the default properties file and Application.app reference.
- Configure DefaultAppLanguage deliberately.
- Use accurately named language, script and region variants.
- Maintain stable, space-free localization keys.
- Review and test numbered placeholders.
- Use resources in metadata, rules and extensions where relevant.
- Test app-defined, iOS-preferred and device language precedence.
- Test unsupported languages and restart requirements.
- Verify offline messages, permissions, IDs, quantities and accessibility.
The full SAP Mobile Development Kit translation guide
1. Identify SAP Mobile Development Kit as the right platform
SAP Mobile Development Kit, often abbreviated MDK, uses app metadata and resource files for multilingual presentation. Its setup is distinct from SAP’s other application frameworks, mobile SDKs, S/4HANA translation tools and generic document translation systems.
Consider a real-world example. A developer searches for ‘SAP translate app’ and encounters instructions for an ERP interface instead of the MDK project. The terminology may overlap, but applying the wrong tool’s menus or file formats causes needless errors.
What to do. Confirm that the project is an MDK application and identify the client, development environment and current metadata. Follow the MDK-specific documentation rather than assuming that every SAP product handles application languages the same way.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
2. Understand internationalization versus localization
Internationalization makes an app capable of supporting different languages and conventions. Localization supplies text and presentation tailored to a particular language or region. SAP’s MDK documentation distinguishes these terms because neither process alone guarantees an understandable product.
Consider a real-world example. A developer externalizes English labels into resource keys and declares the app international. That prepares the architecture, but French readers still need accurate French values, language selection and tests.
What to do. Treat resource architecture as the first step. Then budget for target-language writing, review, fallback decisions, device testing and future updates. Completion means the user can accomplish real work without the interface misleading them.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
3. Use the i18n directory consistently
SAP documents an i18n folder in the MDK project metadata containing a required default properties file and optional language-specific files. Examples include i18n.properties and i18n_de.properties, with additional language, script and region variants.
Consider a real-world example. A project stores its Spanish file in an unrelated directory but keeps a reference to the default i18n file. The app may load the source language yet fail to find the expected target resource.
What to do. Follow the project structure and configured path exactly. Include the intended resources in the deployed metadata, not just the editor’s local files. Test the packaged application on actual devices after deployment.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
4. Configure Application.app’s Localization reference
The MDK documentation says Application.app has a Localization property pointing to the default properties file. Its basename is used when searching for translated files. A mismatch can break language loading even if the translations themselves are correct.
Consider a real-world example. A team names its default file myi18n.properties but writes German strings under an unrelated filename. Device language may be recognized while the application cannot associate the file with the configured resource family.
What to do. Record the path and basename chosen for Localization, then keep variant filenames aligned with it. Validate file presence in metadata and test a language switch in the built client, rather than judging the resource files by appearance.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
5. Set a deliberate DefaultAppLanguage
SAP documents DefaultAppLanguage in BrandedSettings.json; English is the documented default if the property is not specified. This setting is a fallback for supported application language selection, not a substitute for translated content or a legal country determination.
Consider a real-world example. A field-service team targets German readers but leaves the fallback unspecified, assuming a German phone will always make the UI German. On a device without a matching resource file, the experience may revert to English.
What to do. Choose the default explicitly and provide a complete source resource. Test unsupported device languages and record the result. Explain any fallback that might affect a safety or compliance instruction before a user makes a decision.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
6. Name language resource files precisely
SAP describes a filename structure with a base name, language code, optional script and optional region, reflecting language-tag conventions. Examples include myi18n_en_GB.properties and myi18n_zh_Hant_HK.properties.
Consider a real-world example. A Chinese localization team creates one generic file while the product needs separate Simplified and Traditional script coverage. The application may deliver text users cannot read comfortably even though the filename seems to indicate Chinese.
What to do. Specify intended script and region only when the content genuinely supports that variant. Use the documented capitalization and component order, and verify selection against real device settings. Do not treat a filename as proof that a translation has been reviewed.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
7. Understand script matching
The MDK documentation says a script specifier is used only when the device language script matches it. Script differences can be fundamental for written comprehension, not simply stylistic choices.
Consider a real-world example. A Traditional Chinese reader uses a device configured for one script while the app package contains only a Simplified Chinese resource. A fallback may occur, even though both files might otherwise be described as Chinese.
What to do. Test language and script variants separately. Write down which resource file should be selected for each device profile. Supply resources for the actual audience rather than relying on loose language-family labels.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
8. Understand region matching
The documented region specifier identifies a country or region variant, and the app uses that file when the device’s region matches as described. Regional wording may differ in terminology even for the same broad language.
Consider a real-world example. A maintenance app uses English for both British and American technicians. The term for a vehicle part or a measurement convention may need region-specific review, but the underlying work order remains the same.
What to do. Choose a region-specific file only when its wording and review justify the distinction. Test the general language file as a fallback and preserve exact job identifiers, part numbers and quantitative facts across variants.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
9. Write valid key-value properties entries
The MDK documentation presents properties file syntax as Localization_Key=Localized_Value. Keys identify resources and must not contain spaces. The values are the text people read in the chosen language.
Consider a real-world example. A developer types a friendly English sentence with spaces as a key and assumes the parser will treat it like a normal label. The resource may fail or be impossible to reference reliably.
What to do. Use stable, descriptive machine keys such as WORK_ORDER_STATUS, with readable values in each language file. Review for duplicate keys and missing entries. Keep source strings separate from IDs and do not localize database property names merely to change display text.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
10. Choose keys based on meaning
A key should represent what a string does, not only how it happens to be written in the source language. Two visible occurrences of ‘Open’ may need different translations if one means a status and the other means an action.
Consider a real-world example. A technician sees ‘Open’ on a work order and ‘Open’ on a file button. Reusing one key without context may produce an unnatural or misleading translation in languages with different grammatical constructions.
What to do. Name and document keys by workflow meaning. Add brief descriptions, screenshots or source locations to translation handoffs. Reuse a key only when its semantic purpose really is the same across contexts.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
11. Handle comment lines correctly
SAP’s documentation says a properties file line beginning with a hash sign as its first nonblank character is treated as a comment. Comments can assist maintainers but should not be mistaken for translatable strings.
Consider a real-world example. A team includes an explanatory line beginning with # and wonders why the text never appears in the app. The file syntax has treated it as a comment, not an interface value.
What to do. Use comments for controlled notes and keep actual resource entries in valid key=value form. Validate that the application resolves every key referenced by metadata and rules. Check a packaged client rather than relying on text inspection alone.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
12. Understand indexed placeholders
SAP shows placeholders such as {0} and {1} in localized strings, with values supplied at runtime. These are not decorative characters; they stand for information that must be inserted into the translated sentence.
Consider a real-world example. A notification says ‘{0} has sent item {1} to you’. Another language may naturally put the item before the sender. If developers assemble sentence fragments in the original order, the result can be grammatically wrong.
What to do. Let the localized string control wording and placement of supported parameters. Test multiple example values and verify that a translator knows what each placeholder represents. Check that order IDs and person names are not swapped.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
13. Keep placeholder identity stable
A parameter index can carry important meaning, such as the user, work order, amount or date. It must refer to the same underlying value in every localized resource file even when the sentence order changes.
Consider a real-world example. An error message says the minimum required amount is {2}, but a translated string accidentally uses {1}. The screen may show the attempted amount where the minimum should appear, misleading someone correcting the form.
What to do. Create a placeholder specification by resource key, including type and examples. Compare indices in all language versions and test with deliberately distinct values. Do not silently replace missing variables with invented facts.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
14. Use localized strings in metadata and rules
The MDK guide says localization properties can be consumed in metadata definitions and rules, with dedicated references for formatting and localization inside rules. A resource file alone does not ensure every visible string is wired to it.
Consider a real-world example. A work-order page heading resolves a localized key, while a rule-generated error message remains hard-coded in English. The screen is partly localized despite an apparently complete set of files.
What to do. Inspect metadata and rule paths for user-facing text. Replace eligible hard-coded text with the appropriate supported localization references, and test error branches and conditional components rather than just initial page rendering.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
15. Respect application-defined language priority
SAP documents a language precedence order in MDK. An app-defined language selected through the supported SetLanguage action or ClientAPI takes priority when supported, ahead of lower layers such as iOS app preference, device language and default.
Consider a real-world example. A technician sets Spanish inside an app on a phone whose system language is English. The app should follow its documented priority when Spanish resources are available rather than instantly reverting to the phone’s language.
What to do. Write down the intended priority rule and test it on installed builds. Confirm the selected language is supported by deployed resource files; otherwise follow and explain documented fallback behavior.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
16. Know the iOS preferred-language layer
SAP describes an App Preferred Language setting on iOS under Settings > Apps > the app. This layer can override device language but is below an explicit app-defined supported language choice.
Consider a real-world example. An iPhone user selects French for the MDK app while keeping the phone itself in German. Another person sets Italian within the app. They may receive different resource choices because the settings occupy different priority layers.
What to do. Test iOS app preference, overall device language and app-defined selection separately. Do not claim Android exposes exactly the same settings path. Record expected file selection for every supported scenario.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
17. Handle device-language defaults responsibly
The device language is used when higher-priority app settings do not determine a supported language. If the requested language has no packaged properties file, MDK falls back according to its configured hierarchy.
Consider a real-world example. A visitor installs an app on a Norwegian-language device, but the build includes no Norwegian resource file. The app cannot magically produce correct Norwegian labels just because the device requests them.
What to do. List actual packaged languages in release documentation. Test unsupported settings and show an understandable fallback. Never represent a language as supported merely because a device offers it in its operating-system settings.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
18. Understand hard-coded fallback
The MDK documentation lists a final hard-coded language layer after application default and other settings, usually English. This safety net can keep text visible but may be unsuitable for high-stakes tasks whose audience expects another language.
Consider a real-world example. A maintenance warning displays in English when a requested locale is missing. The app remains operational but a worker may not understand the instruction well enough to proceed safely.
What to do. Treat fallback as a continuity mechanism rather than quality assurance. Review critical content for supported audiences, and avoid presenting an unreviewed fallback as a fully localized release.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
19. Plan for iOS restart behavior
SAP notes that when an iOS app falls back to DefaultAppLanguage it may need to be restarted to take full effect, and recommends informing users after language changes. Testing only a freshly launched app can conceal this lifecycle detail.
Consider a real-world example. A person changes the app language and still sees a mixture of old and new labels until restart. They may think the setting was ignored or conclude that two translations are conflicting.
What to do. Test changes during an active session and after a clean restart. Where restart is needed, communicate it clearly and preserve unsaved work before asking the person to close the app.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
20. Differentiate mobile platforms and runtimes
The mobile project may be used on different device platforms and runtime contexts. SAP’s broader documentation distinguishes platform behaviors, so a feature confirmed on one client should not automatically be promised on every other client.
Consider a real-world example. A development team verifies locale fallback on a recent iPhone, then deploys to Android handsets in the field without testing date formatting or navigation layouts. The same resources may surface differently.
What to do. Define the actual deployment matrix and test the user journey on supported devices. Check locale selection, screen size, typography, keyboard input, offline behavior and each business action. Record platform-specific exceptions without overgeneralizing.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
21. Preserve work-order identifiers and status
Enterprise mobile apps often display equipment numbers, case IDs, work orders and approval status. Translation should make these records understandable without changing the authoritative state or identity they represent.
Consider a real-world example. A translated ‘Complete’ button may mean finish the current task, while ‘Completed’ describes the saved status. Confusing the two can make a technician believe an unsent update has reached the server.
What to do. Write separate keys for actions, statuses and confirmations as needed. After each test, compare underlying record identifiers and state transitions. A translated toast is not proof of successful synchronization.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
22. Keep offline work and synchronization truth apart
A mobile app may allow information to be collected while connectivity is unreliable. Translation must not blur the difference between a local draft, a queued sync and a confirmed server update.
Consider a real-world example. A technician sees a translated message that sounds like ‘Report submitted’ while the device has only saved a local draft. They may leave the site assuming colleagues already received the report.
What to do. Test offline and reconnect journeys where relevant to the app. Use status wording tied to actual local and remote states. Keep a visible way to distinguish queued changes from completed server operations.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
23. Format dates and quantities as data
Locale-sensitive formatting belongs to a different layer from string resource translation. A translated label cannot correct a date treated as plain ambiguous text or an amount whose unit was never specified.
Consider a real-world example. A maintenance appointment occurs on 05/06/2026 and a volume reads 1,250.5. Readers in different locales may interpret those strings differently if the app does not display explicit formats or units.
What to do. Use typed values and supported formatting routines. Verify the same calendar instant, quantity, currency or unit across languages. Test day-month ambiguity, negative numbers and decimal separators against authoritative sample records.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
24. Check right-to-left presentation separately
An Arabic or Hebrew resource file does not by itself prove that every MDK screen and extension renders in a correct right-to-left layout. SAP documents RTL behavior separately, and mixed-direction codes require careful handling.
Consider a real-world example. An Arabic maintenance screen contains a Latin serial number, email address and multilingual note. A general direction change can make values hard to copy or read if the application treats every character as reversible.
What to do. Test the supported RTL configuration on actual devices, including field focus, icon semantics, navigation and mixed-script text. Keep serial numbers and URLs in their correct internal order and use native readers for review.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
25. Localize extension controls and special components
Custom controls may carry text outside common metadata properties. SAP’s MDK documentation includes separate material on internationalization for extension modules, signalling that a custom widget may need its own localization review.
Consider a real-world example. A standard screen title is translated, but an extension control displaying a critical inspection status still uses English labels. The user may interpret the custom module differently from the rest of the app.
What to do. Inventory extensions, embedded components and custom messages. Follow the relevant extension documentation and test user-visible output. Do not treat a complete i18n directory as evidence that every plug-in control reads it.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
26. Protect permissions across language changes
A locale selection changes the explanation of a record, not the rights to view, edit or approve it. Enterprise apps must preserve backend access control across screens, API operations and cached records.
Consider a real-world example. An employee cannot view a confidential work order in English. Switching to a different language must not reveal it through a language-specific route or cached alternate screen.
What to do. Test identical roles and records in each locale. Compare forbidden actions, server responses and cached data. A language code should never serve as an authorization credential.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
27. Review errors and recovery instructions
A multilingual mobile app must explain what to do after failed authentication, rejected validation, expired sessions or disconnected networks. These states are often missed when teams translate only primary navigation screens.
Consider a real-world example. A field engineer enters an invalid amount and receives a partially localized warning. If a placeholder displays the wrong number, the explanation becomes not just unclear but factually false.
What to do. Trigger representative errors in every supported language. Check variable indices, precise consequences and the next action offered. Preserve the difference between invalid input, lack of permission and temporary server failure.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
28. Test screen-reader behavior and text expansion
Long target-language text can wrap or clip. Assistive technologies also need meaningful labels and correct language identification where supported. Localized strings alone do not guarantee functional accessibility.
Consider a real-world example. A German translated action uses twice the width of its English source. On a compact phone it collides with another control and hides half the instruction.
What to do. Test small screens, increased text size, focus order, screen readers and high contrast. Favor layouts that accommodate realistic language lengths over artificial abbreviations that remove the meaning of an action.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
29. Audit source file changes and release packaging
Changing a source key requires reviewing corresponding target files, references in rules and the packaged build. An editor may see correct local resources while production clients still run older metadata.
Consider a real-world example. A new required field appears in the source resource, but its translated values were omitted from the release package. The app might display fallback language in exactly the new workflow.
What to do. Track added, renamed and removed keys, review coverage by language, and inspect the deployed artifact. Include target-language resources in ordinary code review and release testing.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
30. Keep public SEO and private MDK apps separate
An MDK field-service application may use multilingual metadata yet remain private and non-indexable. A public website intended for international search requires its own translated pages and search signals. One does not automatically produce the other.
Consider a real-world example. A company advertises language support for its employees’ mobile application and assumes that search engines can now find language-specific product information. Those are separate experiences with different access controls.
What to do. Evaluate the public content strategy on its own merits. Do not expose private operational records merely to create searchable pages. Link users to approved public explanations where appropriate.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
31. Maintain translations after the first release
New functionality, changed safety procedures and product updates introduce new strings and may change the meaning of old ones. A successful localized release can become outdated unless ownership and regression testing continue.
Consider a real-world example. An inspection policy changes the deadline from seven days to three. The original-language instruction is updated but the translated resource still promises seven days.
What to do. Bind translation review to source changes, particularly for consequential wording. Keep revision records and notify reviewers when terms or requirements change. An older fluent translation can be more harmful than a visible missing string.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
32. Measure reliable outcomes, not just key counts
The number of populated properties keys measures coverage of a resource inventory, not the accuracy of the task or a person’s comprehension. Production quality also requires correct UI behavior, backend state and informed user choices.
Consider a real-world example. An app contains every German key but a ‘Cancel work order’ action is translated like ‘Close window’. The count says complete while the action is dangerously ambiguous.
What to do. Run task-based tests with qualified target-language readers. Compare expected and actual record outcomes, record comprehension problems and block serious discrepancies. Use numerical coverage as supporting evidence, not as the only release criterion.
Treat each language choice as a reading condition over the same authoritative business process. Ask what the user believes happened, then check what was actually stored, permitted or transmitted. A correct resource lookup is necessary, but it is not enough if the resulting instruction changes an important consequence.
Hands-on mobile localization QA exercises
Use a test deployment and synthetic work-order records. Each case isolates a configuration or interpretation failure that can otherwise be missed by a simple screen preview. Record the device operating system, configured languages, packaged files, app version, test account and authoritative server result.
Test 1: A device requesting an unshipped language
Install a build without a Norwegian properties file on a Norwegian-configured device, then examine the app’s fallback resource and communicate its limits to a tester.
The app should follow its configured fallback rather than pretending it generated complete Norwegian translations.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 2: A wrong localization basename
Point the test project’s Application.app Localization property at a base filename that does not match target files, then restore the correct configuration.
The exercise isolates packaging and lookup problems from the wording quality of the translations.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 3: An iOS preferred language different from the device
Configure an iOS app preference in French while the device system language is German, then compare results with a supported in-app SetLanguage selection.
Verify the documented precedence only for supported packaged languages.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 4: A missing DefaultAppLanguage property
Remove the property in a safe test build and verify SAP’s documented default behavior, then reintroduce an explicit value.
The result should be understandable and recorded, not treated as an unexplained language selection bug.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 5: Two distinct placeholder values
Use a notification with a person’s name and a work order number. Supply values that are impossible to confuse and check their placement in both language strings.
A grammatical reorder is acceptable; swapping the identity of sender and item is not.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 6: A Traditional and Simplified Chinese comparison
Prepare reviewed resource variants with script names matching the intended locale and test on devices configured for each script.
Resource selection and written content both matter, and a generic ‘Chinese supported’ label may conceal a real gap.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 7: A British versus American wording difference
Test general English and an en_GB variant where the project provides one. Confirm any regional differences are intentional rather than accidental drift.
The same underlying business transaction must be represented accurately in either language variant.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 8: An offline form submission
Prepare a sample record offline, then reconnect and inspect the displayed message before and after actual server synchronization.
Draft, queued and confirmed states must not be conflated by translated success wording.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 9: A failed authorization in two locales
Attempt to read the same protected work order with an account lacking permission, using distinct language settings.
The backend denial must remain consistent; a translated screen should not reveal hidden records.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 10: An ambiguous deadline
Render a deadline with a day and month both below 13 using distinct locale settings and compare the underlying instant.
The visible date needs an unambiguous interpretation without modifying the stored due date.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 11: An RTL identifier on a mobile form
Enter a Latin part number in an Arabic or Hebrew test interface and read it after save, navigation and copy-paste.
Text direction must not corrupt part numbers, phone numbers or typed machine identifiers.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 12: An untranslated extension message
Trigger an error within a custom MDK extension and compare it with the localized ordinary form errors.
Custom controls require their own resource and accessibility review where appropriate.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 13: A key renamed during a source update
Rename one source key in a test change and examine target resource coverage plus metadata or rule references.
New and renamed keys should not silently leave old versions or literal identifiers on screen.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 14: A device language changed during an active session
Change supported language preferences and observe the live app, then restart if relevant to the documented iOS fallback case.
A restart requirement should be communicated without losing unsaved work or claiming the change has already fully applied.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 15: A long target-language button
Test a naturally long translated action on a narrow viewport with larger accessibility text.
The entire action and its consequence must remain readable and operable.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Test 16: A real work-order journey
Open a sample work order, change a field, save, refresh and compare server IDs and statuses in two languages.
Language quality is confirmed only when the same legitimate action yields the same authoritative business outcome.
Capture the exact resource chosen, visible wording and resulting app state. Repeat once after a clean launch or with an intentionally unavailable language. Keep file-selection failures separate from wording errors and backend-state defects; each points to a different place in the project.
Frequently asked questions
Where do MDK language strings live?
The documentation describes an i18n directory in project metadata, with a required default .properties file and optional language-specific files that share a configured basename.
What does the Localization property do?
Application.app references the default localization properties file. The base filename helps the app locate matching translated resources; ensure files and deployed metadata align.
What is DefaultAppLanguage?
It is a fallback language configuration in BrandedSettings.json. The documented default is English when it is not specified, with additional fallback behavior if a resource cannot be used.
Can the user override the device language?
Yes, when a supported language is set by the app through documented SetLanguage or ClientAPI behavior. SAP places this above iOS app preference and device language in the priority order.
Why is iOS app preference different?
iOS offers a per-app preferred language setting that can override device language, though an app-defined supported language has higher priority. Test the particular iOS build rather than assuming the same device path on Android.
What if a requested language file is missing?
MDK follows its configured fallback hierarchy, rather than producing an automatic translation. Check that the packaged metadata includes the intended language resource.
How should placeholders such as {0} and {1} be translated?
Keep the indices tied to their source meanings, while allowing the sentence order to change for natural grammar. Test the rendered output with distinct sample values.
Does changing resource files translate database records?
No. The resources cover the strings the application references. Dynamic business records, comments and external API content need separate language-aware strategies where required.
Does localized MDK metadata create multilingual SEO pages?
No. An authenticated mobile application and a public indexable language-specific page are separate delivery channels. Keep sensitive operational data private and plan public SEO independently.
What proves the release is complete?
The intended resource files load in supported device configurations, target-language users understand decisions, errors remain actionable and backend data and permissions match the authoritative source.
The practical standard
SAP Mobile Development Kit supplies a clear resource-file architecture and a defined language priority. A strong multilingual app uses those features carefully, ships the right files, preserves runtime parameters and makes fallback behavior predictable. But quality is ultimately judged at the moment a real person acts: does the wording describe the same work order, the same rights and the same confirmed outcome in every supported language? When the answer is demonstrably yes, localization has become part of a dependable service.