Localization Strategy

Localization Strategy

End-to-end localization planning for Apple platform apps — from market prioritization through translation workflow to localized App Store optimization.

When This Skill Activates

Use this skill when the user:

• Wants to localize their app for new markets
• Asks "which languages should I support?"
• Needs help deciding market expansion priorities
• Wants to plan a translation workflow
• Asks about internationalization (i18n) best practices
• Mentions "localization", "translation", "multi-language", or "global markets"
• Wants to understand localization ROI by language
• Needs cost estimates for translation
• Asks about right-to-left (RTL) layout support
• Wants to localize App Store metadata (title, description, keywords, screenshots)

Process

Phase 1: Market Prioritization Framework

Not all languages are equal. Prioritize by revenue potential, not just speaker count.

Revenue Potential by Language

Based on App Store revenue data and per-user spending patterns:

Key insight: Japanese and German users often pay 2-3x more per user than Spanish or Portuguese users. Volume vs. value is the fundamental tradeoff.

Category-Specific Priorities

App category changes which languages to prioritize first:

Factors to Evaluate

For each potential language/market, assess:

Use AskUserQuestion to gather the user's app category, current markets, and budget constraints before making recommendations.

Phase 2: Language Tier Recommendations

Tier 1 — Highest ROI (Localize First)

Recommendation: Localize into 2-3 Tier 1 languages first. Expected combined revenue lift: 20-50%.

Tier 2 — Good ROI (Localize Second)

Recommendation: Add Tier 2 after Tier 1 languages prove ROI. Expected per-language lift: 3-8%.

Tier 3 — Volume Play (Localize for Scale)

Recommendation: Tier 3 is for apps that already have strong Tier 1 and Tier 2 performance and want maximum global reach.

Phase 3: Minimum Viable Localization Levels

Not every language needs full localization on day one. Start small, measure, then invest.

Level 0: Metadata-Only

What you localize:

• App Store title and subtitle
• App Store description
• App Store keywords
• Screenshots (text overlays and captions)
• Promotional text

What stays in English:

• All in-app UI
• Help/support content
• Push notification text

Cost: $100-300 per language (professional translation of ~500 words) Effort: 1-2 days per language Best for: Testing whether a market responds before investing further

Why this works: Users search the App Store in their language. Localized metadata means your app appears in local searches. Many users worldwide are comfortable with English UI but discover apps through local search terms.

Level 1: Metadata + UI Strings

What you localize:

• Everything in Level 0
• All user-facing strings (Xcode String Catalogs export)
• Date/time/number format adaptation
• System alerts and error messages

What stays in English:

• In-app content (help articles, onboarding guides)
• Marketing materials
• Support communication

Cost: $500-3,000 per language (depending on string count) Effort: 1-2 weeks per language (including QA) Best for: Languages that showed strong Level 0 results

Level 2: Full Localization

What you localize:

• Everything in Level 1
• In-app content (onboarding, tutorials, help text)
• Marketing website and materials
• Customer support in-language
• Legal documents (privacy policy, terms of service)
• Push notifications and emails

Cost: $3,000-10,000+ per language Effort: 3-6 weeks per language Best for: Top 1-2 markets by revenue, when the language represents >15% of revenue

Recommended Approach

Step 1: Ship Level 0 for 2-3 Tier 1 languages
Step 2: Measure downloads and revenue lift per language (4-6 weeks)
Step 3: Invest in Level 1 for languages that showed >5% download lift
Step 4: Invest in Level 2 only for markets generating >15% of total revenue

This approach limits risk. If Japanese Level 0 doesn't move the needle, you saved yourself $2,000+ in translation costs.

Phase 4: Translation Workflow

Xcode String Catalogs

String Catalogs (.xcstrings) are the standard localization format.

Export workflow:

1. Ensure all user-facing strings use String(localized:) or LocalizedStringResource
2. Build the project — Xcode auto-discovers strings
3. Open the .xcstrings file to see all strings with translation status
4. Export: Product > Export Localizations (creates .xcloc bundles)
5. Send .xcloc files to translators
6. Import: Product > Import Localizations

String Catalog best practices:

• Add comments to strings that need context (e.g., "Title of settings screen" or "Button label, max 15 characters")
• Use string interpolation with proper grammar agreement (Foundation's automatic grammar support)
• Mark strings that should NOT be translated (e.g., brand names) with "Don't Translate"
• Review the "Stale" state — it flags strings whose source changed after translation

Translation Service Options

AI + human review workflow:

1. Export strings from Xcode
2. Run through high-quality AI translation (provide app context and glossary)
3. Native speaker reviews and corrects (1-2 hours for 500 strings)
4. Import back into Xcode
5. Test in-context (some translations don't work in UI context)

Cost Estimates by App Size

Budget planning: For a medium app localizing into 3 Tier 1 languages at Level 1: ~$3,000-9,000 total.

Review Process

Native speaker review is mandatory.

Review checklist per language:

• Grammar and spelling correct
• Tone matches the app's voice (casual, professional, playful)
• Technical terms translated consistently (use a glossary)
• No literal translations that sound unnatural
• String length fits UI constraints (check for truncation)
• Culturally appropriate (no unintended meanings)
• Placeholder variables render correctly (%@, %d, etc.)

Phase 5: Cultural Adaptation Beyond Translation

Translation is necessary but not sufficient. Cultural adaptation catches issues that literal translation misses.

Date, Time, and Number Formats

Rule: Always use Foundation formatters. Never hardcode format strings.

// CORRECT - adapts to locale automatically
let formatter = Date.FormatStyle()
    .year().month().day()
Text(date.formatted(formatter))

// CORRECT - number formatting
Text(price.formatted(.currency(code: "JPY")))

// WRONG - hardcoded US format
Text(String(format: "%m/%d/%Y", date))

Currency Display

• Always use the user's locale for display, even if your product is priced in USD
• App Store handles currency conversion for IAP — but display in marketing materials should match locale
• Some markets are sensitive to seeing foreign currencies (Japan especially)

Color Meanings

Recommendation: Use semantic system colors (Color.red for errors) and let the system handle meaning. Avoid using color as the ONLY way to convey information (accessibility requirement too).

Layout Direction

RTL languages (require layout mirroring): Arabic, Hebrew, Urdu, Persian

What to mirror:

• Navigation direction (back button on right)
• Text alignment (leading becomes trailing)
• Horizontal scroll direction
• Progress indicators (fill from right)
• Icons with directional meaning (arrows)

What NOT to mirror:

• Media playback controls (play, pause, skip)
• Phone number input
• Clocks and timers
• Brand logos

SwiftUI RTL support:

• Use .leading and .trailing instead of .left and .right
• Use @Environment(\.layoutDirection) for conditional layout
• Test with: Edit Scheme > Run > Options > Application Language > Right to Left Pseudolanguage

Image and Icon Localization

Some images need localization:

• Screenshots showing text (localize the text)
• Icons with text or cultural symbols
• Hand gesture icons (thumbs up, OK sign differ by culture)
• Body language icons (eye contact norms differ)

Phase 6: Localized App Store Optimization (ASO)

Why Localized ASO Matters

• Localized App Store metadata increases conversion rate 30-80% in non-English markets
• Users search in their native language, even if they can use English apps
• App Store search algorithms weight localized keywords for each storefront
• Localized screenshots dramatically improve first impressions

Keyword Research by Market

Critical: Do NOT just translate your English keywords. Keyword search behavior differs dramatically by market.

Localized keyword research process:

1. Translate your top 10 English keywords as a starting point
2. Use WebSearch to find what local users actually search for: "[category] app" site:[country-domain]
3. Check local competitors' keywords (what terms do their listings target?)
4. Ask a native speaker: "How would you search for an app that does [X]?"
5. Test different keyword sets per locale and measure impressions

Localized Screenshots

Screenshots are the most impactful localization investment after metadata.

What to localize in screenshots:

• Overlay text and captions (translate and adapt, don't just translate)
• App content shown in screenshots (use locale-appropriate sample data)
• Feature callouts (highlight features that matter most in that market)
• Device frames (use devices popular in that market if relevant)

What to keep consistent:

• Overall visual style and branding
• Screenshot order (unless market research suggests different feature priority)
• App icon

Cost-effective approach: Create screenshot templates with text layers. Swapping text is fast and cheap compared to redesigning screenshots per locale.

Competitor Analysis by Storefront

Use WebSearch to research competitors in each target storefront:

• Which apps rank for your keywords in Japan vs. Germany vs. Brazil?
• Are local competitors absent from some markets? (opportunity)
• What pricing do competitors use in each market?
• What App Store categories are they listed under? (may differ by market)

Phase 7: Testing Localized Builds

Xcode Preview with Locale Override

Test UI in different locales without changing device settings:

#Preview {
    ContentView()
        .environment(\.locale, Locale(identifier: "ja"))
}

#Preview {
    ContentView()
        .environment(\.locale, Locale(identifier: "de"))
}

#Preview {
    ContentView()
        .environment(\.layoutDirection, .rightToLeft)
}

Pseudo-Localization

Catch localization bugs before real translations arrive:

Accented English: Replaces characters with accented versions (e.g., "Settings" becomes "[Seeetttiiiinnggss]"). Helps catch:

• Hardcoded strings that bypass localization
• Character encoding issues

Double-length strings: Doubles every string. Helps catch:

• Truncation in fixed-width UI elements
• Layout overflow
• Buttons that can't grow

Right-to-Left: Mirrors layout. Helps catch:

• Hardcoded .left / .right instead of .leading / .trailing
• Icons that need mirroring
• Layout assumptions

Enable in Xcode: Edit Scheme > Run > Options > Application Language > choose pseudo-language.

String Length Testing

Translation length varies significantly by language:

Implication: If your English UI barely fits, German will definitely overflow. Design with 30% padding for text elements, or use dynamic type sizing.

Screenshot Testing Across Locales

Automate localized screenshot capture:

1. Use Xcode UI tests with XCUIApplication().launchArguments to set locale
2. Capture screenshots in each supported locale
3. Review for truncation, layout breaks, and placeholder leaks (%@ visible in UI)
4. Verify sample data matches locale expectations

Localization QA Checklist

Run this for every supported language before release:

• All strings translated (no English fallbacks visible)
• No truncated text in any screen
• Date/time/number formats correct for locale
• Currency displays correctly
• Pluralization rules work (many languages have complex plural forms)
• RTL layout correct (if applicable)
• Images with text localized
• App Store metadata reviewed by native speaker
• Screenshots localized and accurate
• Dynamic Type works with translated strings
• VoiceOver reads localized strings correctly

Output Format

Present the localization roadmap as:

# Localization Roadmap: [App Name]

## Current State
- **Supported languages**: [List]
- **App size**: [Small/Medium/Large] ([N] strings)
- **App category**: [Category]

## Market Prioritization

### Recommended Languages (Priority Order)

| Priority | Language | Tier | Level | Est. Revenue Lift | Est. Cost | Timeline |
|----------|----------|------|-------|-------------------|-----------|----------|
| 1 | [Language] | Tier 1 | Level [0/1] | +X-Y% | $X-Y | [N weeks] |
| 2 | [Language] | Tier 1 | Level [0/1] | +X-Y% | $X-Y | [N weeks] |
| 3 | [Language] | Tier [1/2] | Level [0/1] | +X-Y% | $X-Y | [N weeks] |

### Total Budget Estimate
- **Phase 1** (Tier 1 languages): $X-Y
- **Phase 2** (Tier 2 languages): $X-Y
- **Total**: $X-Y

## Translation Workflow
1. [Export method]
2. [Translation service]
3. [Review process]
4. [Import and QA]

## Localized ASO Plan
- **Keywords**: [Research approach per market]
- **Screenshots**: [Localization approach]
- **Description**: [Translation + adaptation approach]

## Cultural Adaptations Required
- [Adaptation 1]
- [Adaptation 2]

## Testing Plan
- [ ] Pseudo-localization pass
- [ ] Native speaker review per language
- [ ] Screenshot testing per locale
- [ ] RTL testing (if applicable)
- [ ] String length / truncation audit

## Timeline

| Phase | Duration | Languages | Level | Milestone |
|-------|----------|-----------|-------|-----------|
| 1 | Weeks 1-2 | [Languages] | Level 0 | Metadata live, measure downloads |
| 2 | Weeks 3-6 | [Languages] | Level 1 | Full UI localized for top performers |
| 3 | Weeks 7-10 | [Languages] | Level 0 | Tier 2 metadata test |
| 4 | Ongoing | [As needed] | Level 1-2 | Expand based on data |

## Success Metrics
- Downloads per locale (before vs. after localization)
- Conversion rate per storefront
- Revenue per locale
- Review ratings per locale (watch for localization complaints)

## Next Steps
1. [First action item]
2. [Second action item]
3. [Third action item]

Integration with Other Skills

This skill connects to the broader product development pipeline:

1. product-agent              --> Validate idea
2. market-research            --> Identify global opportunity
3. competitive-analysis       --> Check competition per market
4. localization-strategy      --> THIS SKILL
   (THIS SKILL)
5. app-store                  --> Localized App Store listing
6. monetization               --> Regional pricing strategy

Inputs from other skills:

• market-research provides TAM/SAM/SOM data that helps prioritize markets
• competitive-analysis reveals which markets have fewer localized competitors
• monetization informs regional pricing (App Store price tier selection)

Outputs to other skills:

• Prioritized language list feeds into app-store for localized metadata
• Regional competitor data informs competitive-analysis per market
• Revenue projections per market feed into monetization strategy

Common Mistakes to Avoid

Translating keywords literally

Bad:  English keyword "to-do list" translated literally to Japanese
Good: Research what Japanese users actually search for (Japanese users often
      search for the concept differently than a literal translation)

Hardcoding date/number formats

Bad:  String(format: "%m/%d/%Y", date)
Good: date.formatted(.dateTime.year().month().day())

Ignoring string length differences

Bad:  Fixed-width button that fits "Save" but not "Speichern" (German)
Good: Flexible layout that adapts to any string length

Localizing everything at once

Bad:  Translate into 15 languages at Level 2 before validating demand
Good: Level 0 for 3 languages, measure for 4 weeks, then invest in winners

Skipping native speaker review

Bad:  Ship AI-translated strings without human review
Good: Every translation reviewed by a native speaker in-context

Using left/right instead of leading/trailing

Bad:  .frame(alignment: .left)
Good: .frame(alignment: .leading)

Localization is not translation — it's making your app feel native in every market. Start with metadata, prove demand with data, then invest in full localization where the numbers justify it.