Prompt
building a localization workflow for a startup app
Latest observation
Here’s a practical localization workflow you can use for a startup app, optimized for speed, low overhead, and future scale.
1) Set up your i18n foundation early
Choose a localization approach that supports:
- Message keys instead of hardcoded strings
- Pluralization
- Variables/placeholders
- Date, number, and currency formatting
- RTL support if needed later
Typical setup:
- Store source strings in a single canonical language, usually English
- Use a structure like:
en.jsones.jsonfr.json
Example:
{
"welcome": "Welcome, {name}!",
"items_count": "{count} items"
}
2) Create a content ownership process
Decide who owns what:
- Product/PM: defines copy changes and translation priority
- Engineering: implements keys and localization infrastructure
- Design: checks layout for longer strings
- Translator/localizer: translates strings and adapts tone
For a startup, keep it simple:
- One person owns the string source of truth
- One person approves translations before release
3) Extract strings into a translation source
Avoid scattering text across the codebase.
Workflow:
- Dev adds or updates UI text
- Extract to localization files or a translation management system (TMS)
- Mark strings with context notes if needed:
- where used
- character limits
- meaning/disambiguation
Example note:
"Save"= button label, not file saving
4) Use a translation management system if possible
If you’re handling more than 1–2 languages, use a TMS like:
- Phrase
- Lokalise
- Crowdin
- POEditor
Benefits:
- Translation history
- Collaboration
- Context for translators
- QA checks
- Easy import/export to your app
If budget is tight, start with:
- Git-based JSON/YAML files
- A spreadsheet for tracking
5) Define a release cadence
Don’t localize ad hoc. Batch it.
Recommended workflow:
- Sprint includes copy changes
- New strings merged to main branch
- Localization team translates weekly
- QA checks builds before release
For fast-moving startups:
- Ship English first
- Localize top-priority screens only
- Expand language coverage gradually
6) Build guardrails for developers
Add checks so localization doesn’t break quietly:
- Missing key detection
- Fallback language
- Linting for hardcoded strings
- CI checks for malformed JSON
- Tests for pluralization rules
Example guardrails:
- Fail build if a required locale key is missing
- Warn on unused keys
- Detect string interpolation errors
7) Add context for translators
Good translations need context, not just strings.
Include:
- Screenshot of the UI
- Field description
- Tone guidance
- Character limits
- Gender/plural rules
- Link to product glossary
Create a glossary for:
- Product names
- Feature names
- Terms that should remain untranslated
8) Handle locale-specific formatting
Make sure your app supports:
- Dates:
MM/DD/YYYYvsDD/MM/YYYY - Numbers: commas and decimals
- Currency symbols and placement
- Time zones
- Sorting and collation
- Units: metric vs imperial
Use locale-aware libraries rather than manual string formatting.
9) Design for translation expansion
Some languages are longer than English.
Design checks:
- Buttons should flex
- Avoid text baked into images
- Allow multi-line labels where needed
- Test with pseudo-localization early
Pseudo-localization example:
- Expand text length by 30–40%
- Add accented characters
- Surface layout issues before real translation
10) QA the localized build
Test each language for:
- Truncated text
- Broken layouts
- Incorrect plural forms
- Wrong date/number formatting
- RTL mirroring issues
- Missing keys or fallback strings
Best practice:
- Use screenshots or device testing
- Review critical user flows: signup, checkout, onboarding, settings
11) Track localization as part of product metrics
Measure:
- Translation turnaround time
- Number of missing keys
- Locale coverage
- Conversion or retention by locale
- Bugs caused by localization
This helps you decide which languages to prioritize next.
12) Keep the process lightweight at startup stage
A lean workflow could be:
- Dev adds strings with keys
- Strings go into JSON files or TMS
- PM reviews source text
- Translator localizes
- QA checks in staging
- Merge and ship
Tools to keep it simple:
- JSON/YAML or gettext
- GitHub Actions for validation
- A shared glossary in Notion/Google Sheets
- Screenshot-based QA in staging
Suggested startup-friendly workflow
If you want the simplest scalable version:
- Source of truth:
en.json - Translation store: Lokalise/Crowdin or Git
- Review: PM + engineer
- QA: staging build + pseudo-localization
- Release: weekly or per sprint
A good first-step checklist
- Replace hardcoded strings with keys
- Add pluralization support
- Choose a translation storage method
- Create a glossary
- Add fallback locale
- Add CI checks for missing keys
- Test one screen with pseudo-localization
- Define who approves translations
If you want, I can also turn this into:
- a step-by-step workflow diagram,
- a Notion/Confluence template, or
- a technical implementation plan for React, iOS, Android, or Flutter.