March 24, 2026·10 min read

i18n: plurals, RTL, and the strings you forgot

English has lazy plural rules. Other languages don’t. RTL isn’t just `row-reverse`—icons, chevrons, and animations need thought. A short checklist saves rework after translation arrives. Front-load the hard strings (counts, dates, navigation) instead of bolting i18n on at the end.

Plurals and gender

Never glue English like count plus items in one string; use i18next plural keys or ICU messages. Translators will send the file back if you do not.

Provide context comments in JSON for ambiguous strings.

RTL layout

Use start/end over left/right in styles when possible. Mirror icons that imply direction (back arrows).

Test with pseudolocale or real Arabic early, not the week before launch.

Formatting

Dates, currency, and numbers belong to the locale, not hardcoded US formats. `Intl` helpers are your friend.

Don’t ship all locales if you only test two; partial locales confuse users.

Before you hand off to translators

Export a glossary for product terms, flag strings with parameters, and screenshot complex screens. Run a pseudolocale build to catch truncation: German often needs 30% more horizontal space than English.

RTL: verify swipe gestures and carousels—mirroring animation direction matters as much as flex direction.

Plural rules beyond English

Languages vary in plural categories—two forms are not universal. Use ICU or i18next plural features; never concatenate counts manually. Zero often needs its own string. Provide translators context comments; ‘book’ ambiguous strings create rework. Review compiled bundles for missing keys before release.

RTL layout mechanics

Prefer `start`/`end` over `left`/`right` in styles. Mirror directional icons and animations thoughtfully—some icons stay universal. Test with real RTL locales early; pseudolocale helps but is not enough. Watch third-party components for hard-coded LTR assumptions.

Formatting numbers, dates, and currency

Use `Intl` and locale-aware helpers; never hardcode US formats. Currency needs both amount and currency code clarity. Relative times (‘2h ago’) need periodic refresh—coordinate timers with battery impact. Test calendar edge cases across timezones for scheduling features.

String length and layout overflow

German and Finnish strings run long; design flexible layouts. Truncation needs tooltips or expansion affordances. All-caps styling breaks some scripts—avoid globally. Line height and diacritics need extra vertical space in some languages.

Translation workflow

Export stable keys; avoid churning keys unnecessarily. Provide screenshots for complex screens. Define glossary for product terms. Handle translator questions in a shared channel. Version translation files alongside app versions for reproducibility.

Testing and QA matrices

Cover at least one RTL language and one verbose language in QA sign-off. Automated screenshot tests across locales catch clipping. Verify sorting and search behave per locale rules. VoiceOver/TalkBack in translated languages catches reading-order issues.

Launch checklist

No missing keys in prod, pluralization verified, formats correct, RTL tested, legal copy aligned, and support docs updated for localized names of features. i18n bugs look like typos but erode trust fast—allocate time accordingly.

Shipping and reliability habits (1)

OTA updates are powerful and risky: runtime compatibility, rollback plans, and user-visible behavior changes need governance. Channels should map to release maturity—staging versus production—with access controls on publish credentials. Large assets over cellular need care; silent failures erode trust more than a frank ‘update failed, retry’ message.

Keyboard and form UX separate polished apps from ‘works on desktop simulators.’ Platform differences in soft input modes matter; test smallest phones and Android gesture navigation. Primary actions must remain reachable when the keyboard is visible—scroll containers and keyboard controllers exist because this problem is universal.

Platform differences worth rehearsing (2)

Expo SDK upgrades are integration projects: `expo doctor`, aligned community packages, regenerated native projects, and device smoke tests for camera, push, and IAP. Freeze unrelated native refactors during the upgrade window and keep rollback paths hot. Document surprises for the next upgrade while memory is fresh.

Hermes versus JSC is not a lifestyle choice—profile your app. Hermes usually wins on startup; some libraries still assume JSC quirks. Engine toggles are not substitutes for fixing quadratic renders in your own code. Upgrade notes matter: Intl support and debugging tooling evolve.

Security, privacy, and data handling (3)

Metro cache issues masquerade as logic bugs. Establish a documented reset ladder: dev server restart, cache flags, Watchman, derived data, then dependency reinstalls. Compare platforms when only one breaks—native steps diverge. Keep CI caches deterministic with lockfiles and pinned toolchains.

Environment variables should be classified: public-by-design, sensitive-with-mitigations, or never-on-device. `EXPO_PUBLIC_` values are extractable—treat them that way. Align env handling across EAS profiles and local dev; fail fast when keys are missing instead of shipping undefined behavior.

Performance and measurement discipline (4)

Internationalization is a product feature, not a string swap. Plural rules, RTL layout, and locale-aware formatting change behavior—not just copy length. Pseudolocale helps find clipping early, but real Arabic and German QA catches nuance. Avoid concatenating translated fragments; context matters. Document glossary terms so translators do not invent inconsistent product names.

Monorepos amplify both leverage and failure modes: duplicate React versions cause mysterious hook errors, and Metro misconfiguration blocks local packages from resolving. Invest in workspace discipline—single React version, documented `watchFolders`, and lint rules preventing packages from importing app navigators accidentally. CI must mirror local installs; ‘works on my laptop’ with different package managers is a time bomb.

Team process and long-term maintenance (5)

WebViews are untrusted browsers inside your app. Validate `postMessage` payloads, lock navigation to expected hosts, and prefer system-browser auth flows when OAuth security demands it. Third-party JavaScript can change without your deploy—treat XSS in web as bridge compromise risk. Clear storage on logout and rate-limit message handlers.

E2E tests should protect revenue paths, not every permutation. Stable selectors (`testID`) beat text that marketing rewrites weekly. Flake management is a feature: quarantine, fix root causes, and keep smoke suites green on CI devices. Five reliable tests beat fifty flaky ones that everyone ignores.

Shipping and reliability habits (6)

In-app purchases require server validation, restore flows, and support tooling that respects privacy. Sandbox quirks are normal—budget QA time. Subscriptions interact with family sharing, regional pricing, and refunds; engineering must stay aligned with finance and legal narratives users see in receipts.

Privacy nutrition labels and Play Data Safety forms should reflect actual SDK behavior—inventory dependencies each release and remove dead code. Drift between claims and telemetry is legal and store risk, not just embarrassment. Involve legal early when adding analytics or ads.

Platform differences worth rehearsing (7)

Design tokens and semantic colors make dark mode and rebrands feasible. Mixing three styling systems doubles migration cost—pick a primary approach and draw boundaries. Runtime CSS-in-JS can cost frame time on hot screens—profile before adopting wholesale.

ScrollView versus FlatList is a data-volume question. Small static content belongs in ScrollView; long feeds belong in virtualized lists. Nested scrollables need explicit height contracts—redesign beats fighting physics. Document intentional choices so future refactors do not ‘optimize’ blindly.

Security, privacy, and data handling (8)

Security and privacy expectations move faster than roadmaps. Treat analytics, crash, and attribution SDKs as part of your threat model: initialize them deliberately, document data flows, and verify ‘off’ truly stops network calls. Client-side secrets are public secrets—anything shipped in an APK or IPA should be assumed extractable. Pair mobile changes with backend policies so authorization remains consistent across platforms.

Accessibility is compatibility. Labels, focus order, and dynamic type are not polish—they determine whether users can complete tasks at all. Test with VoiceOver and TalkBack on hardware; simulators miss focus bugs. When designs prioritize minimalism, negotiate text alternatives for icon-only controls. Accessibility regressions often follow navigation redesigns—add checklist items to those PRs specifically.

Performance and measurement discipline (9)

Error boundaries catch render failures, not native crashes or async mistakes. Pair them with platform crash reporting and structured client logs. Fallback UI should include build identifiers and humane copy—never raw stack traces for end users. Test fallbacks with screen readers; a broken error screen is still broken UX.

Storage is not a database. AsyncStorage and MMKV excel at key-value preferences; SQLite or remote APIs belong elsewhere for relational data. Migrations should be incremental, logged, and non-blocking for UI. Secure tokens need secure storage when your model demands it—speed is not a substitute for correctness on auth material.

Team process and long-term maintenance (10)

Splash screens and launch gates should reflect honest readiness: fonts, theme, session, critical remote config—not every SDK under the sun. Infinite splash is worse than a slightly longer branded hold. Match native and JS background colors to avoid flashes; respect reduced motion for animations.

JWT and session refresh flows need single-flight refresh, clear logout semantics, and secure storage for refresh tokens when appropriate. Parallel 401s should not stampede refresh endpoints. Clock skew and biometrics policies belong in explicit product decisions, not accidental implementation details.

Shipping and reliability habits (11)

Platform differences worth rehearsing (12)

FlatList performance is configuration as much as code. Stable keys, reasonable `windowSize`, and memoized rows beat switching to a different list primitive blindly. Nested virtualized lists are a last resort—redesign first. Profile with production-like data volumes; dev placeholders lie.

Security, privacy, and data handling (13)

Reanimated and gesture libraries earn their place when profiling proves UI-thread work and your team can maintain native upgrades. Worklets have constraints—read errors carefully. Respect reduced motion and test Android timing differences—identical JS does not guarantee identical feel.

Performance and measurement discipline (14)

Team process and long-term maintenance (15)

Performance work should start with measurement, not instinct. Watch JS thread versus UI thread separately; they bottleneck differently. Lists, images, and animations dominate most regressions—optimize those before micro-optimizing pure functions. Hermes, JSC, and bridge internals evolve; re-profile after every major upgrade instead of trusting last year’s numbers. Battery and thermal throttling on mid devices reveal issues flagship phones hide.

Shipping and reliability habits (16)

Deep links are a cross-team system: marketing URLs, hosted association files, entitlements, router params, and analytics query preservation. Debug with structured logging of raw URLs (scrub secrets) and reproduce cold-start races with auth hydration. Staging and production should be obviously separated—accidentally opening prod from a QA link erodes trust and pollutes data.

Push notifications walk a line between helpful and intrusive. Prime users with context, respect notification channels on Android, and measure opt-outs after campaigns—spikes mean copy or frequency problems. Payload design affects background behavior; test killed and locked-device states. Tokens belong server-side with rotation strategies; never treat the client as authoritative for subscription state.

NewerAccessibility labels that help instead of annoy OlderToken refresh on mobile without random logouts

Project structure → · App utilities →