ShipLingua — localization concierge for solo Steam devs

1. One-liner

Turns a solo dev’s game + Steam page into a sign-off-ready localized build they can trust in languages they don’t read.

2. Trend signal — why now?

Three things collided in the last 12 months.

First, Simplified Chinese overtook English as the #1 language on Steam (Valve’s own GDC data, 2024), and it stays #1 or near-#1 through 2026. The money to be made from non-English players is no longer a rounding error — 64% of Steam players don’t play in English. Store-page localization alone reportedly drives “30 to 50% more interest” from those markets.

Second, the release firehose exploded — ~19,000 games shipped on Steam in 2024, 32% more than 2023, and ~80% of them got no traction. A solo dev’s single cheapest lever to stand out in a non-English market is a native-feeling store page and UI, and almost nobody does it.

Third, context-aware LLM translation got good and cheap enough that a $6k Simplified Chinese pass now produces documented outcomes like $97k in first-60-day revenue for a solo narrative dev, or a two-person studio going $1.8k/mo → $14k/mo after adding PT-BR/ES/RU. The ROI case is no longer speculative — it’s in the blog posts and the SteamDB charts.

But the incumbents chasing this (Crowdin, Lokalise, Gridly, Alconost) are TMS platforms built for studios that already run a localization pipeline. The solo dev has no pipeline, no PM, and — the killer — no ability to verify output in a language they can’t read. That last gap is where the opportunity sits.

Provenance:

• Signal 1 (Demand): Indie devs repeatedly call localization “difficult and expensive,” fall back to volunteers/DeepL, and decline offers because “I can’t verify the quality / can’t put it out officially when I don’t know what it says.” — https://itch.io/tools/tag-localization + https://itch.io/post/8381316 — 2026-07-25
• Signal 2 (Feasibility): Context-aware AI translation + MTPE now standard for indie loc at $0.10–0.15/word, 40–50% cheaper with MT post-edit; store-page format is small and structured. — https://crowdin.com/blog/game-localization + https://www.transphere.com/game-localization-costs/ — 2026-07-25
• Signal 3 (Economic): Game localization market $2.5B (2024) → $7.1B (2033); Simplified Chinese #1 on Steam; store-page loc drives 30–50% more interest; documented indie ROI ($6k → $97k/60d; 7x revenue). — https://alconost.com/en/blog/steam-language-mix-indies + https://homebusinessmag.com/blog/gaming/indie-devs-7x-revenue-smart-video-game-localization/ — 2026-07-25 Category: Underserved niche

3. The opportunity

The incumbents sell the wrong shape of product to this customer. Crowdin and Lokalise are $100–500+/mo subscription TMS tools designed to be administered — you upload string tables, wire integrations, manage translators, review in a web console. That’s rational for a 20-person studio. For a solo dev it’s a second job.

And they don’t solve the actual blocker. Talk to solo devs and the objection isn’t “translation costs too much” — it’s “I don’t speak Chinese, so I can’t tell if the translation is good, embarrassing, or offensive, and I won’t ship something official that I can’t read.” Multiple devs on itch.io say exactly this, verbatim. Raw MT — even good MT — makes that fear worse, not better.

ShipLingua flips the model:

1. One-shot, done-for-me, per-game — not a subscription platform to run. Point it at your Steam page URL + export your in-game strings, get back a finished localized store page (in Steam’s format, with culturalized tags/descriptions) and a context-aware localized string set.
2. A trust layer that lets a monolingual dev sign off — every translated line ships with a back-translation into English, a plain-language “here’s what this actually says,” and flags for cultural landmines, UI-overflow risk, and untranslatable idioms. The dev reviews in a language they do read, and approves with confidence.

That trust/sign-off layer is the product. The translation is table stakes.

4. Target market

• Primary customer: Solo and micro-studio (1–3 person) developers shipping a text-light-to-medium game on Steam — systems games, pixel Metroidvanias, cozy sims, narrative shorts. English-native, targeting Simplified Chinese + a couple of Tier-1/high-ROI languages (PT-BR, ES-LATAM, German, Russian).
• Why they buy (their words): “Translation is expensive and I can’t verify it.” “I can’t put out an official translation when I don’t know what it says.” “I’d love Chinese but hiring someone or waiting for volunteers isn’t viable.” They want the ROI without the pipeline or the trust gap.
• Rough TAM reasoning: ~19,000 Steam releases/year, ~14,000+ of them small/indie. Even if only 15–20% seriously consider paid localization at some point in their release cycle, that’s 2,000–3,000 new candidate games per year, recurring, plus a back-catalog of hundreds of thousands of already-shipped English-only indie titles that never localized. This is a large, continuously-refilling top of funnel.
• Why now for them: Simplified Chinese is the #1 Steam market; the release glut makes discoverability desperate; and the documented ROI cases ($6k → $97k) circulate in every indie marketing community. FOMO is real and current.

5. Product sketch (MVP)

• Store-page localizer: paste your Steam page URL → get localized title, short/long description, “About This Game,” and market-appropriate tags/keywords, formatted to paste straight into Steamworks per language.
• In-game string localizer: upload your CSV/PO/Unity String Table/Godot .csv export → get a context-aware translated file back in the same format, ready to drop in.
• Context ingestion: attach screenshots and a short game-description brief so the AI knows tone, lore, and where each string appears (fixes the “is ‘Home’ a house or a button?” problem).
• Trust & sign-off panel: every line shows original ↔ translation ↔ back-translation ↔ plain-English gloss, with flags for cultural risk, profanity, UI-overflow (too long for the button), and low-confidence lines. The dev approves or requests a redo per line.
• Human-in-the-loop upgrade: one-click “send flagged lines to a vetted native reviewer” for the ~5–10% the AI itself marks uncertain (marketplace of freelance reviewers, ShipLingua takes a cut).
• Re-run on update: patch your game, re-upload strings, only the changed lines get re-translated and re-flagged — cheap incremental passes.

6. AI angle — what’s load-bearing

Remove the AI and there’s no product — it’s a Fiverr gig. The AI does four jobs that are individually hard and collectively unaffordable to do manually at this price point:

1. Context-aware translation that reads screenshots + brief, not a naked string list — the difference between publishable and embarrassing.
2. Back-translation + plain-English gloss — the trust layer that makes a monolingual dev willing to sign off. This is the core insight and it’s pure LLM work.
3. Cultural/overflow/profanity flagging — catching the landmines the dev can’t see, at scale, per line.
4. Confidence scoring to route only the genuinely-uncertain lines to paid human review, keeping the price low and the margin healthy.

7. Localization angle (if any)

N/A as a geography wedge — this is a global play by nature (the customer is global, the value is localization). The nuance: ShipLingua should itself prioritize the highest-ROI target languages (Simplified Chinese first, then PT-BR, ES-LATAM, German, Russian) and encode Steam’s per-region storefront quirks and tag taxonomies, because generic “translate anything” tools miss the platform-specific culturalization that drives the ROI.

8. Business model — path to $1M–$5M ARR

• Pricing: Per-game, per-language passes. Store-page pack: $79/language. Full game (store + in-game strings, up to N words): $199–$499/language depending on word count. Human-review add-on: $0.04–0.06/flagged word (marketplace, ~40% take). Optional “update pass” credits.
• ACV: A typical buyer does store + strings for 2–3 languages at launch → $600–$1,200 per game, plus update passes and a possible second game later. Call blended ACV ~$450 including single-language-only buyers.
• Rough math to $1M ARR: ~2,200 game-projects/year at ~$450 blended = $1M. That’s <1% of the ~2,500 annual serious-loc-candidate indie games plus back-catalog. Achievable.
• Rough math to $5M ARR: ~11,000 projects/year, i.e. real penetration of the annual indie cohort + back-catalog reactivation + higher attach of human-review marketplace revenue (which scales ACV without new logos). Needs strong word-of-mouth in indie communities and possibly a Steamworks/engine-marketplace listing.
• Expansion path: more languages per game, update passes (recurring per patch), human-review marketplace take rate, and adjacent one-shots (localized trailer subtitles, capsule-art text, patch notes). Consumer/self-serve, so land-and-expand is per-game not per-seat.

9. Go-to-market wedge — first 100 customers

• Scrape the fresh-release + Coming Soon lists on SteamDB/Steam for English-only games with no or few languages listed, run ShipLingua on their public store page, and send the dev a free localized Chinese store-page sample of their actual game with the back-translation trust panel attached. “Here’s your page in Chinese — the #1 Steam market — proofread-ready. Want the rest?” This is the killer cold outreach: it’s their game, it’s the highest-ROI language, and it demonstrates the trust layer in one shot.
• Post in the indie marketing watering holes where the ROI narrative already lives: r/gamedev, r/IndieDev, the “How To Market A Game” community, TigSource, and indie Discords — with a real before/after ROI teardown, not an ad.
• List on the engine marketplaces (Unity Asset Store, Godot Asset Library) as a “localize your game + Steam page” utility — devs already search there for localization plugins.
• Partner with 2–3 indie-marketing YouTubers/newsletters (Chris Zukowski / “How To Market A Game” audience is exactly the buyer) for a sponsored teardown showing the sign-off panel.
• Wishlist-driven timing: target games in the “Coming Soon” 4–8 week window before launch, when devs are actively optimizing the store page and most receptive.

10. Build complexity — justification

Medium. The translation, back-translation, flagging, and confidence-scoring are all off-the-shelf LLM calls orchestrated well — no custom models. The real work is (a) robust ingestion/round-tripping of the messy file formats (Unity String Tables, Godot .csv, PO, raw CSV) without corrupting keys or breaking encodings, (b) Steam store-page scraping + correct per-region formatting/tags, and (c) the sign-off UX that makes trust feel real. A 1–2 person team ships a credible v1 (Chinese + 2 languages, store-page + CSV/PO strings) in ~3–4 months; the human-review marketplace is a fast-follow, not v1.

11. Gating checklist

Gate	Pass?	Note
Legal in target market	✅	Translation-as-a-service; devs own their content and sign off on output.
Ethical — no harm / dark patterns	✅	The trust layer is anti-dark-pattern — it exists to stop devs shipping content they can’t vouch for.
Market exists (evidence above)	✅	Documented spend, incumbents, ROI cases, verbatim complaints.
1–5 person team can build this	✅	Orchestrated LLM calls + file plumbing + a review UI.
Launchable with <$50K / ₹40L	✅	Off-the-shelf APIs; main cost is dev time + inference.

12. Feasibility score

Axis	Weight	Score	Notes
Problem intensity	20	15/20	Real, recurring, ROI-obvious pain — but it’s a “grow revenue” pain, not “hair on fire / losing money today,” and many devs punt localization to post-launch.
Demand evidence	15	12/15	Multiple independent signals: verbatim complaints, incumbents charging money, documented ROI, market growth. Skeptic nods. Docked because most evidence is about the category, less about willingness to pay this specific one-shot model.
Build feasibility	15	11/15	No model work, but file round-tripping and Steam formatting are fiddly; sign-off UX must feel trustworthy. ~3–4 months, not 6 weeks.
Distribution clarity	15	12/15	The “here’s your actual game’s page in Chinese, free” cold sample is a strong, named, cheap wedge with a scrapable list. Conversion unproven.
Revenue mechanics	15	11/15	Per-game pricing benchmarked against Fiverr + TMS; ACV modest and buyers are often one-and-done, so it leans on volume + back-catalog + marketplace take.
Time to first revenue	10	8/10	Self-serve, pre-sellable via free samples; revenue within weeks of a working store-page module.
Defensibility	10	5/10	Execution + trust-UX + Steam-specific culturalization are the moat; the underlying MT is commodity and incumbents could bolt on a “solo mode.” Head start + niche brand, not a hard moat.
Total	100	74/100

13. Qualitative modifiers

Founder-fit tags

technical-heavy (LLM orchestration + file-format plumbing + scraping) · content-heavy (distribution runs on ROI teardowns and community credibility in indie-gamedev circles).

Key assumptions to validate (3–5)

1. Assumption: Solo devs will pay $79–$499/language for a done-for-me one-shot rather than DIY with DeepL or wait for volunteers. How to test: run the free-Chinese-store-page cold sample on 100 Coming-Soon games; measure paid conversion on the “buy the rest” upsell.
2. Assumption: The back-translation / sign-off panel is what unlocks the sale (trust, not price). How to test: A/B two landing pages — one leading with “cheap AI localization,” one leading with “localize confidently in languages you can’t read” — compare demo-request rate.
3. Assumption: The AI’s context-aware output + flagging is good enough that devs actually trust and ship it. How to test: blind-review 10 sample outputs with paid native speakers per language; target ≥90% “publishable without major edits.”
4. Assumption: File round-tripping works across the real spread of indie formats without corrupting builds. How to test: run against 20 real open-source Godot/Unity projects’ string files end-to-end.

Risk flags

1. Platform dependency: Heavy reliance on Steam’s store-page structure and on LLM APIs. Steamworks changes or an engine shipping native AI localization could compress the wedge.
2. Incumbent fast-follow: Crowdin/Lokalise/Gridly could add a “solo, one-shot, with sign-off” mode. Mitigant: own the indie-gamedev brand and the trust-UX before they notice the segment.
3. Market timing (AI backlash): A vocal slice of indie/itch.io culture is explicitly “no AI” and may shun AI localization on principle. Mitigant: position as AI-drafted + human-verifiable + optional native review, and target the pragmatic Steam-commercial devs, not the itch.io art crowd.
4. One-and-done ACV: Buyers may localize once and never return, forcing constant new-logo acquisition. Mitigant: update passes, back-catalog reactivation, and marketplace take-rate to grow revenue per customer.

14. Structured verdict

Score:                  74/100
Verdict:                GO
Confidence:             Medium
Best-fit builder:       Technical founder comfortable with LLM orchestration + a gamedev-community-native marketer
Time to revenue:        6–10 weeks (store-page module + free-sample funnel)
Capital to launch:      ₹4–8 lakh ($5–10K) — mostly inference + dev time
Top 3 assumptions to validate first:
  1. Paid conversion on the free-Chinese-store-page cold sample (100-game test)
  2. Trust-first positioning beats price-first positioning (landing A/B)
  3. Output quality ≥90% "publishable" in blind native review
Kill criteria:
  - Abandon if <3% of 100 cold free-sample recipients convert to a paid pass
  - Abandon if blind native review rates <70% of AI output "publishable without major edits"
  - Abandon if a major incumbent ships an indie-priced one-shot + sign-off mode before your v1

15. Next step — 1-week validation sprint

• Day 1–2: Scrape 100 English-only “Coming Soon” Steam games. Hand-run (even manually with an LLM) a Simplified Chinese store-page translation + back-translation trust sheet for each.
• Day 3–4: Cold-email all 100 devs their own game’s Chinese store page for free, with a one-line offer: “Want the full page + in-game strings, sign-off-ready, for $X?” Track opens, replies, and pre-order interest.
• Day 5: Decide go / no-go. Falsifiable bar: ≥5 of 100 devs express concrete paid intent (reply asking price/how-to-buy) AND ≥3 of 5 blind native reviewers rate the sample store pages “publishable.” Below either bar → no-go or rework the wedge.