How can you localize a Draftbit mobile app for multiple languages without assuming that the builder has translated every screen? This Draftbit and Expo localization guide explains device-language detection, translation dictionaries, compatible NPM packages, custom code, app language preferences, and the testing needed before an iOS or Android release. It is useful for product teams that need a controlled multilingual application rather than a one-time machine-translated screen.
Draftbit’s current documentation describes React Native and Expo mobile projects with TypeScript, and supports compatible NPM packages and code customization. Expo’s official localization guide documents expo-localization for reading locale preferences and examples using i18n-js for translated strings. These are building blocks, not proof that a new Draftbit project includes a fully configured automatic translation system; exact package setup and native build behavior depend on the project’s generated code and installed versions.
The central idea is to separate source meaning from presentation. A product record, login permission, payment result and tracking number must remain truthful when someone changes languages. A welcome label is easy to demonstrate, but the useful test is an entire journey: first launch, sign-in, search, form, error recovery, and a later return after the device language changes. This chapter shows where to place responsibility and how to inspect the real app.
The quick answer
Treat Draftbit as a React Native/Expo project whose localization design must be explicit. Choose a compatible internationalization library and device-locale approach, maintain reviewed string resources and stable keys, and connect language selection to rendering and persistence. Verify package compatibility with the exact Expo SDK and test actual native preview builds after changing native packages. Do not equate recognizing a locale with translating data, server errors or store listings.
What to check before launch
- Read the generated project’s framework and package versions, not a remembered tutorial.
- Choose a library that supports the project’s Expo and React Native setup.
- Confirm what expo-localization provides and what a translation library provides.
- Externalize source-language strings into stable contextual keys.
- Decide on app language preference, fallback and supported locales.
- Keep record IDs, permission rules and backend state separate from labels.
- Rebuild native previews when native dependencies or configuration change.
- Test plural rules, regional formatting, right-to-left use and accessibility.
A practical way to understand the system
Draftbit provides a route to the underlying application code. That flexibility helps when a product requires nuanced localization, but it also means the application owner must design the translation system. Device locale detection tells the app about preferences; a string library selects approved words; business APIs provide authoritative facts; deployment ensures the correct resources reach the device. Each part needs its own test.
1. Start from the generated project, not from an assumed builder menu
Draftbit’s September 2026 FAQ describes mobile projects in TypeScript, React Native and Expo. A team’s exact project may have a different history or package versions. Open its package.json and settings before following a localization tutorial written for an older Draftbit interface.
A real-world situation
A builder is told to open a ‘Custom Code’ pane, but their current workspace uses Settings and Packages. The concept of adding localization remains useful even when interface locations have changed.
Where teams get into trouble: The mistake is treating a screenshot from a previous product version as a permanent API. Teams may waste time or install incompatible dependencies.
A better approach: Confirm your project type, toolchain and Expo SDK. Use Draftbit’s current package instructions and build a minimal bilingual proof-of-concept.
What to verify: Record the actual dependency versions, where translation resources live and what build version was tested.
A reliable translation is a promise about the next action, not just a replacement for a string. A reader should be able to predict what happens after tapping the control. If a label changes meaning while the underlying action stays the same, the interface has become less transparent even when its grammar is correct.
2. Know what expo-localization does
Expo’s official guide documents expo-localization for retrieving device and calendar preferences. It does not translate sentences itself. A translation library such as i18n-js or another compatible solution is responsible for mapping message keys to language strings.
A real-world situation
A weather app detects that a phone prefers Italian. The library can tell the app what the preference is, but ‘Rain expected’ remains English until an approved Italian message exists.
Where teams get into trouble: Teams sometimes declare victory after logging a locale code while leaving every user-visible string hard-coded.
A better approach: Test locale detection separately from lookup. Return a readable fallback for missing resources and distinguish chosen app language from detected device language.
What to verify: Verify a device preference produces the intended translation string and does not silently change the weather forecast values.
A screenshot can prove that a word appeared, but it cannot prove that the visitor understood the task. A useful test records what the person expected, what they selected and what the application actually did. The gap between those three observations is where language defects become visible.
3. Choose one translation library deliberately
Expo’s localization documentation uses i18n-js as an example; its API reference also names other React-oriented libraries. Choose based on formatting, pluralization, types, extraction, integration and team capability rather than popularity alone.
A real-world situation
A simple museum app may need a small dictionary, while a marketplace with many plural forms and dynamic messages needs stronger message tooling.
Where teams get into trouble: Mixing multiple libraries or embedding ad hoc replacements in components produces inconsistent fallback rules and maintenance debt.
A better approach: Compare the needs of a sample screen, install only a compatible solution and write a short convention for keys, interpolation and errors.
What to verify: A reviewer can locate a message by key, understand its context and test it through the running app.
The safest multilingual design keeps business facts separate from the words chosen to describe them. Stable identifiers, verified totals and permission rules should survive a locale change. Only presentation and legitimately localized content should vary. This distinction prevents translation from silently rewriting evidence.
4. Install compatible packages and rebuild when needed
Draftbit’s package guidance says Expo-compatible packages and supported auto-linking or config plugins matter for native apps. Native dependency changes can require fresh preview builds; web preview behavior alone cannot prove mobile compatibility.
A real-world situation
A team adds expo-localization and immediately inspects an old Android build that predates the native package installation.
Where teams get into trouble: The application appears broken even though the problem is a stale native binary, or appears fine on the web while the native platform lacks required configuration.
A better approach: Pin suitable package versions, test installation and make a new native preview when code or configuration changes require it. Review actual build logs.
What to verify: The packaged app includes the expected library and behaves as documented on iOS and Android.
The person encountering an error is often under pressure. Give them a recovery path in the same language, explain whether anything was saved and avoid claiming that a transaction succeeded until the system confirms it. Recovery messages deserve as much translation attention as welcoming text.
5. Create stable keys with clear contexts
A source phrase should map to a distinct identifier representing its action and context. The English words ‘Open’, ‘Close’ or ‘Order’ can mean different things depending on whether they describe a status, a verb or a button.
A real-world situation
A restaurant app uses ‘Order’ for food checkout and for changing how a list is sorted. A single ambiguous key could produce nonsense in a target language.
Where teams get into trouble: Blind text substitution ignores grammar, context and different actions with similar English labels.
A better approach: Use purpose-based keys such as checkout.placeOrder and list.sortOrder, with comments for translators and a clear source of truth.
What to verify: Review both screens in the target language and confirm each label predicts the correct action.
Internationalization is easier to maintain when every change has a known owner. A small edit to a default-language screen can affect multiple translations and devices. Treat new interface strings as a release change, not as harmless decorative copy, and revisit all supported language journeys.
6. Design a safe default and fallback chain
A device may report a region-specific locale that the app does not ship. Decide whether to match a regional variant, a base language or a clearly disclosed default. Avoid returning an empty key or showing mixed-language paragraphs.
A real-world situation
A phone prefers French from Canada, but the app only supports general French and English.
Where teams get into trouble: A missing exact match can leave the interface with raw keys or crash a poorly designed message lookup.
A better approach: Normalize supported locale codes explicitly and test exact, regional and entirely unsupported preferences. Keep fallbacks deterministic.
What to verify: The user sees coherent text and can discover which languages the app offers.
An effective review distinguishes the platform’s documented feature from an application’s chosen implementation. An editor may expose a convenient language setting, but the product team still owns database responses, email templates, legal claims, accessibility and the meaning of outcomes. Never infer complete coverage from a settings page.
7. Differentiate device preference from deliberate app choice
Expo describes per-app language selection in newer operating systems and gives configuration examples for supported locales. Some products also allow an in-app preference. Decide which source wins when they disagree.
A real-world situation
A bilingual person sets a navigation app to Spanish while leaving their phone and keyboard in English.
Where teams get into trouble: An app that overwrites the person’s choice on every launch can feel unstable and may force them into the wrong language.
A better approach: Define preference priority, persist it appropriately and test system settings changes, first installation and reinstallation.
What to verify: The language after a restart matches the documented selection policy.
A reliable translation is a promise about the next action, not just a replacement for a string. A reader should be able to predict what happens after tapping the control. If a label changes meaning while the underlying action stays the same, the interface has become less transparent even when its grammar is correct.
8. Handle Android and iOS locale lifecycle differences
Expo’s guide notes differences when device language changes while an application is running. Android may require reevaluating getLocales when the app returns to the foreground; iOS typically resets the app on system change.
A real-world situation
A person changes device language in Settings then returns to a still-open Android app, expecting newly selected text.
Where teams get into trouble: A translation system initialized only at app startup may continue displaying a stale locale indefinitely.
A better approach: Use the appropriate app lifecycle or localization hooks, and test native behavior with the exact installed SDK version.
What to verify: The displayed language updates according to the chosen policy without losing valid user data.
A screenshot can prove that a word appeared, but it cannot prove that the visitor understood the task. A useful test records what the person expected, what they selected and what the application actually did. The gap between those three observations is where language defects become visible.
9. Make pluralization a first-class requirement
The number of grammatical plural categories differs by language. An English template built around singular and plural cannot simply be copied to languages with additional categories.
A real-world situation
A delivery app displays one parcel, two parcels and several parcels across English, Arabic and Polish.
Where teams get into trouble: Joining a count to a fixed noun may be fluent in one language but wrong in another, undermining both clarity and credibility.
A better approach: Use a message system that supports the required language’s plural forms and verify representative quantities including zero, one and other values.
What to verify: Readers see natural, accurate quantities while numeric totals remain unchanged.
The safest multilingual design keeps business facts separate from the words chosen to describe them. Stable identifiers, verified totals and permission rules should survive a locale change. Only presentation and legitimately localized content should vary. This distinction prevents translation from silently rewriting evidence.
10. Treat interpolation as structured meaning
Names, counts, amounts and links inserted into messages should be typed and formatted rather than glued into untranslated sentence fragments. Languages may place a variable at a different point in a sentence.
A real-world situation
A booking confirmation includes a guest name, date and service category in one message.
Where teams get into trouble: String concatenation can force English word order, mishandle currency or expose a malformed placeholder to readers.
A better approach: Let translators work with complete messages and context, and validate that required placeholders survive every variant.
What to verify: A confirmation reads naturally and preserves the exact data from the authoritative booking record.
The person encountering an error is often under pressure. Give them a recovery path in the same language, explain whether anything was saved and avoid claiming that a transaction succeeded until the system confirms it. Recovery messages deserve as much translation attention as welcoming text.
11. Use proper regional formatting
Expo localization surfaces locale information; formatting dates, currencies and units remains an application responsibility. Do not assume a translated sentence automatically changes a date from month/day to day/month.
A real-world situation
A customer in the United States and a customer in Germany review the same appointment timestamp.
Where teams get into trouble: An ambiguous ’04/05/2026′ may refer to different days, while a silently reformatted price can misstate the currency.
A better approach: Use appropriate locale-aware formatting tools, carry time zones explicitly and label currency units wherever confusion is costly.
What to verify: Both readers can describe the same timestamp and amount in a way consistent with the source system.
Internationalization is easier to maintain when every change has a known owner. A small edit to a default-language screen can affect multiple translations and devices. Treat new interface strings as a release change, not as harmless decorative copy, and revisit all supported language journeys.
12. Preserve stable API data and enum values
A translation layer should present readable labels for stable coded values. Record IDs, payment status, authorization claims and SKU identifiers must never change merely because the user switches languages.
A real-world situation
A shipping app stores status code IN_TRANSIT and displays a localized phrase for the current user.
Where teams get into trouble: Saving the translated label instead of the stable code can break search filters and downstream integrations.
A better approach: Store stable values in the backend and localize them at display time; test two languages against one shared record.
What to verify: The record’s true state is unchanged and every displayed label corresponds to it.
An effective review distinguishes the platform’s documented feature from an application’s chosen implementation. An editor may expose a convenient language setting, but the product team still owns database responses, email templates, legal claims, accessibility and the meaning of outcomes. Never infer complete coverage from a settings page.
13. Localize error messages without hiding useful detail
Backend error responses often contain codes designed for programs, not people. A localized interface should map known codes to clear recovery messages while preserving diagnostic detail for support.
A real-world situation
A server returns ‘AUTH_SESSION_EXPIRED’ when a user tries to upload a form in a second language.
Where teams get into trouble: Showing a cryptic English code as the entire message makes it difficult for users to recover; falsely showing ‘uploaded’ is worse.
A better approach: Convert structured error codes into reviewed messages, say whether data was saved and offer safe next actions.
What to verify: An in-language user can decide whether to sign in, retry or contact support without guessing.
A reliable translation is a promise about the next action, not just a replacement for a string. A reader should be able to predict what happens after tapping the control. If a label changes meaning while the underlying action stays the same, the interface has become less transparent even when its grammar is correct.
14. Do not make a language selector destructive
A language change should not silently erase a drafted message, cart or form data. The state transition may cause components to rerender; test that rerender with partially completed tasks.
A real-world situation
Someone writes a long accommodation request, selects Japanese for assistance and loses the text.
Where teams get into trouble: The selector becomes a dangerous control even when all its visible labels are correct.
A better approach: Separate state from presentation, persist drafts where appropriate and handle confirmation before any unavoidable reset.
What to verify: The draft remains available or the interface clearly warns the user before an irreversible action.
A screenshot can prove that a word appeared, but it cannot prove that the visitor understood the task. A useful test records what the person expected, what they selected and what the application actually did. The gap between those three observations is where language defects become visible.
15. Support right-to-left and mixed-script layouts
RTL presentation affects alignment, navigation, icons and sometimes animation direction. A right-to-left language can still contain left-to-right product codes, URLs or currency fragments.
A real-world situation
An Arabic order summary includes a Latin tracking identifier and a mixed numeric phone number.
Where teams get into trouble: A naive global text reversal can corrupt IDs and make copy-and-paste or navigation unreliable.
A better approach: Use the platform’s appropriate RTL configuration, test mixed-direction segments and check all important screens on native builds.
What to verify: Readers can follow the layout and copy exact identifiers unchanged.
The safest multilingual design keeps business facts separate from the words chosen to describe them. Stable identifiers, verified totals and permission rules should survive a locale change. Only presentation and legitimately localized content should vary. This distinction prevents translation from silently rewriting evidence.
16. Keep accessibility labels in the same language
Screen readers announce information from accessibility labels and hints, not necessarily the visible text alone. Localization needs to include these resources and interaction order.
A real-world situation
A German-language screen has a settings icon whose hidden accessibility label still says ‘go back’.
Where teams get into trouble: A blind user can trigger the wrong action despite a visually correct translated interface.
A better approach: Use language-aware accessibility names, sensible focus movement and large-text checks with actual assistive technology.
What to verify: A screen-reader user can understand a control and predict its action without visual help.
The person encountering an error is often under pressure. Give them a recovery path in the same language, explain whether anything was saved and avoid claiming that a transaction succeeded until the system confirms it. Recovery messages deserve as much translation attention as welcoming text.
17. Be careful with translation bundles and loading
A large app may load some language resources only when a screen opens. Decide how the interface behaves while those resources are unavailable or offline.
A real-world situation
An app starts in Spanish but opens a seldom-used help page before its Spanish message bundle has loaded.
Where teams get into trouble: An unexplained blank screen or raw translation keys can look like a product failure.
A better approach: Define loading and fallback behavior, cache safely where supported and test the complete offline or weak-network journey.
What to verify: Users see clear availability information rather than incomplete technical placeholders.
Internationalization is easier to maintain when every change has a known owner. A small edit to a default-language screen can affect multiple translations and devices. Treat new interface strings as a release change, not as harmless decorative copy, and revisit all supported language journeys.
18. Preserve security across locale boundaries
Translations and language parameters are not a security model. Every API request must enforce normal permissions regardless of what locale code or string is sent.
A real-world situation
A multilingual appointment portal lets a visitor change from English to French, but should never expose another patient’s appointment.
Where teams get into trouble: A poorly designed language endpoint can accept different record identifiers without enforcing ownership.
A better approach: Test authenticated and unauthenticated requests for each locale and verify access controls at the backend.
What to verify: Unauthorized records remain inaccessible under all language selections.
An effective review distinguishes the platform’s documented feature from an application’s chosen implementation. An editor may expose a convenient language setting, but the product team still owns database responses, email templates, legal claims, accessibility and the meaning of outcomes. Never infer complete coverage from a settings page.
19. Remember native and web behavior may differ
Draftbit can produce projects that share concepts across platforms, but package compatibility and layouts may vary across web and native builds. A browser test is a helpful check, not a substitute for mobile testing.
A real-world situation
An on-screen locale switch works in web preview but an iOS binary lacks configured supported-locales metadata.
Where teams get into trouble: Teams may claim system language selection works everywhere based on one platform’s behavior.
A better approach: Test the exact platforms you support; rebuild native binaries after configuration changes and record where features differ.
What to verify: Documented behavior matches the shipped target platform rather than a convenient preview.
A reliable translation is a promise about the next action, not just a replacement for a string. A reader should be able to predict what happens after tapping the control. If a label changes meaning while the underlying action stays the same, the interface has become less transparent even when its grammar is correct.
20. Translate notifications and store copy separately
Push alerts, email templates, app-store descriptions and privacy disclosures may be outside the message dictionary shipped with the application. Each needs an owner and localization workflow.
A real-world situation
A user chooses Portuguese in the app but receives an English payment notice with a different date convention.
Where teams get into trouble: A polished app screen cannot compensate for confusing transactional communications.
A better approach: Audit notification templates, push payloads, deep links and store listings as separate release surfaces.
What to verify: External text and in-app screens describe the same confirmed transaction in compatible languages.
A screenshot can prove that a word appeared, but it cannot prove that the visitor understood the task. A useful test records what the person expected, what they selected and what the application actually did. The gap between those three observations is where language defects become visible.
21. Create regression tests for future code changes
Once translated, an application can regress when someone changes components, keys or routing. Automated missing-key checks help but should be paired with human meaning review.
A real-world situation
A developer renames a key used on a checkout button, leaving three language dictionaries unchanged.
Where teams get into trouble: The build can succeed while the UI renders a raw key or an inappropriate fallback at the moment of payment.
A better approach: Add translation coverage checks to pull-request and release review, with critical journey tests on real devices.
What to verify: New builds retain readable language and correct outcomes across the supported locales.
The safest multilingual design keeps business facts separate from the words chosen to describe them. Stable identifiers, verified totals and permission rules should survive a locale change. Only presentation and legitimately localized content should vary. This distinction prevents translation from silently rewriting evidence.
Practice workshop: complete journeys rather than isolated screens
1. A fresh device with an unknown locale
Launch the app on a phone whose language is not among your translated dictionaries. Clear local preferences first.
Inspect detected locale values, the fallback chain and how the app reports supported languages. Verify the fallback is a deliberate choice, not a lookup exception.
An acceptable result looks like this: The complete first screen is usable and understandable.
Repeat the exercise in the default language and the second language, on a fresh installation or browser profile as appropriate. Compare the same underlying record and action. Note any difference caused by translation separately from differences caused by permissions, caching, connectivity or regional business rules.
2. The count that changes grammar
Show zero, one, two, five and twenty-one items in several languages.
Use a real plural-aware message rather than concatenating a noun after a number; check with a competent reviewer for the target language.
An acceptable result looks like this: Quantity and grammar are correct while the count itself remains authoritative.
Perform the action once with valid data and once with an intentionally invalid or incomplete input. Then try a return visit. Keep the test account and data stable, record the actual system result, and ask a reader to explain the message without seeing the source-language original.
3. A stale Android language change
Keep the app open, change the operating-system language, return and navigate to a new screen.
Check app-state behavior and when getLocales is reevaluated. Compare the result with the product’s explicit language-preference policy.
An acceptable result looks like this: The app changes language according to the documented policy without data loss.
Repeat the exercise in the default language and the second language, on a fresh installation or browser profile as appropriate. Compare the same underlying record and action. Note any difference caused by translation separately from differences caused by permissions, caching, connectivity or regional business rules.
4. The per-app language on iOS
Configure supported locales for a test binary and use system app-language settings where available.
Build a new native preview if the config plugin or native metadata changed. Test the actual installation, not an old binary.
An acceptable result looks like this: System settings expose the intended choices and the app responds predictably.
Perform the action once with valid data and once with an intentionally invalid or incomplete input. Then try a return visit. Keep the test account and data stable, record the actual system result, and ask a reader to explain the message without seeing the source-language original.
5. The inaccessible icon
Enable a screen reader and open a second-language settings screen.
Listen to all icon labels, focus hints and the result after tapping. Do not evaluate by screenshot alone.
An acceptable result looks like this: Controls are announced and actionable in the selected language.
Repeat the exercise in the default language and the second language, on a fresh installation or browser profile as appropriate. Compare the same underlying record and action. Note any difference caused by translation separately from differences caused by permissions, caching, connectivity or regional business rules.
6. The partially filled form
Fill a form halfway, change languages, return to the same task and intentionally submit invalid data.
Verify persistence of fields, localized validation and clear disclosure of whether anything reached the server.
An acceptable result looks like this: The user can finish safely without rebuilding the form.
Perform the action once with valid data and once with an intentionally invalid or incomplete input. Then try a return visit. Keep the test account and data stable, record the actual system result, and ask a reader to explain the message without seeing the source-language original.
7. An offline language resource
Open a rarely visited page with networking disabled and one language resource unavailable.
Observe whether the app uses a documented fallback or explains limited availability; it must not confuse missing translations with missing business records.
An acceptable result looks like this: The page remains coherent or declares why the content cannot be shown.
Repeat the exercise in the default language and the second language, on a fresh installation or browser profile as appropriate. Compare the same underlying record and action. Note any difference caused by translation separately from differences caused by permissions, caching, connectivity or regional business rules.
8. The renamed key regression
Change one UI label and refactor its translation key in a test branch.
Run key coverage checks and review every supported dictionary. Inspect critical native screens after the change.
An acceptable result looks like this: No old or raw key leaks into the shipped interface.
Perform the action once with valid data and once with an intentionally invalid or incomplete input. Then try a return visit. Keep the test account and data stable, record the actual system result, and ask a reader to explain the message without seeing the source-language original.
9. The transaction state proof
Make a payment request succeed, pend and fail across two locales.
Map backend states to distinct human messages. Compare actual transaction IDs and statuses with the displayed result.
An acceptable result looks like this: The app never claims payment completed before the provider confirms it.
Repeat the exercise in the default language and the second language, on a fresh installation or browser profile as appropriate. Compare the same underlying record and action. Note any difference caused by translation separately from differences caused by permissions, caching, connectivity or regional business rules.
Four-week practical rollout
Week 1: Project discovery
Inspect generated code, dependency versions and product journeys. Select realistic languages, one authoritative default and a translation-resource convention. Identify backend and notification texts that the app library does not control.
Record which parts require custom code, native configuration or a separate service. Confirm the team can maintain the chosen packages over time.
Week 2: Build a complete language slice
Add a compatible localization library and a small set of reviewed messages. Connect device preferences and an intentional app-language policy. Translate one complete screen-to-action-to-result journey.
Test the native preview with a second language, missing resource and long strings before translating everything.
Week 3: Expand and test failure paths
Cover pluralization, interpolation, time zones, empty states, validation, authentication, accessibility and RTL where needed. Change device language during an Android app session and verify platform-specific behavior.
Perform critical checks on actual iOS and Android builds and verify the server enforces the same permissions in all locales.
Week 4: Release with ownership
Verify package versions, binary metadata, notifications, store descriptions and translation dictionaries together. Run regression tests after every significant source-text change.
Publish only when meaningful task outcomes, not just text coverage, are correct; keep a clear mechanism for fixing future translation defects.
Frequently asked questions
Does Draftbit automatically translate every screen?
Do not assume so. Draftbit’s current documentation centers on generated Expo/React Native projects and extensible packages. Translation resources and runtime logic still need to be designed and tested.
Which device-locale package is documented by Expo?
Expo documents expo-localization for reading locale preferences. It is not itself a complete dictionary of translated UI messages.
Can I use i18n-js?
Expo uses i18n-js in an official example. Check compatibility and exact configuration for your generated project and choose the library that meets your formatting needs.
How do I add packages?
Draftbit documents package management in Settings and AI Chat for current projects. Consult the current product documentation and the project’s actual configuration.
Why must I rebuild native previews?
Native package and configuration changes may not be present in an older installed preview. A fresh native build is necessary to test the shipped dependency configuration.
What should happen when a locale is unsupported?
Use a predictable, tested fallback and let the user understand what is available. Do not show raw keys or pretend unsupported translations exist.
Does a locale change alter customer permissions?
It must not. Authorization is a backend responsibility that stays independent of display language.
Should I translate status codes?
Translate the presentation labels, not the stored machine-readable codes. Preserve authoritative state and identifiers.
Can translations be correct but the app unusable?
Yes. Clipped buttons, misleading dates, inaccessible labels and incorrect error messages can prevent safe task completion.
What proves localization is ready?
A complete, independently tested user journey in every supported locale on the native platforms you will actually ship.
What successful localization should feel like
A Draftbit app feels genuinely multilingual when its words, code, data and device behavior agree. A user can change language without losing a draft, recognize a reliable deadline, recover from an error and trust a transaction outcome. That result comes from deliberate software design, reviewed content and repeatable native testing—not from detecting a locale code alone.
Primary documentation and further reading
- Draftbit FAQ — generated project languages and frameworks (September 2026)
- Draftbit Docs — adding packages and Expo compatibility
- Draftbit FAQ — packages and native modules
- Expo — localization guide
- Expo — expo-localization API
- Translate Like a Pro — series index
- Master Art of Translation — complete system