LocProof

1. One-liner

Drop in your game’s string files and LocProof flags the truncations, broken variables, and machine-translation smells that tank your per-language Steam reviews — before you ship, not after.

2. Trend signal — why now?

Three things collided in the last twelve months:

1. Steam changed the scoreboard. On 18 August 2025, Steam switched from one blended review score to localized review scores — a German player now sees the rating built from German reviews only (threshold: 2,000 total reviews with ≥200 in that language). Valve’s own line: “There’s now no way of hiding a poor localization.” A bad Japanese translation used to be diluted by 5,000 happy English reviews. Now it shows up naked to every Japanese browser. Some developers are reportedly delaying localizations entirely to protect their day-one rating — which is exactly the wrong outcome, because localization can add 30–50% of revenue.

2. The cost wall is real and getting worse per-word. Human-led indie localization runs $0.10–$0.15/word, or $5K–$30K for the big-five languages (text-heavy RPGs blow past $30K), and LQA — the human bug-hunt pass that catches truncation and context errors — roughly doubles the bill. Most cozy/narrative indies budget $3–5K total. The QA pass is the first thing they cut. So they ship, and Japanese RPG reviews — which “skew proportionally more negative” and treat broken translations, tiny fonts, and awkward phrasing as deal-breakers — do the damage.

3. Context-aware linguistic QA got cheap. Generic MT still “treats text as a simple list of strings” and hallucinates (“Tank” the vehicle vs. the class vs. the container), overflows UI, and drifts on tone/lore. But LLMs are now good and cheap enough to run those checks — placeholder integrity, glossary/lore consistency, tone drift, MT-smell detection — while font-metric truncation is trivial deterministic code. The enterprise TMS players (Gridly Auto QA, lexiQA, Crowdin AI) have this — but only inside their platform, custom-priced, for teams already living in a TMS.

Provenance:

• Signal 1 (Demand): Indie localization costs $5K–$30K for five languages, $0.10–$0.15/word, LQA roughly doubles it; broken translations are launch-killers for text-heavy JP/RPG titles — https://www.transphere.com/game-localization-costs/ and https://calcix.net/guides/business-startup/global-game-expansion-profitability-guide — 2026
• Signal 2 (Economic / Platform shift): Steam localized review scores went live 18 Aug 2025 (“no way of hiding a poor localization”); devs reportedly delaying localization to protect day-one ratings — https://www.ecigames.net/media/august-2025-new-changes-to-steams-localized-review-score-ratings — Aug 2025
• Signal 3 (Feasibility): Context-aware Auto QA (placeholder validation, truncation, glossary, MT-detection) is proven but TMS-locked (Gridly Auto QA, lexiQA add-on, Crowdin AI) — https://crowdin.com/blog/game-localization and https://www.gridly.com/integrations/lexiqa/ — 2026 Category: Platform shift

3. The opportunity

Every localization QA tool on the market assumes you already live inside a TMS. Gridly’s Auto QA and the lexiQA add-on are features of Gridly. Crowdin AI checks run inside Crowdin. Enterprise, custom-priced, built for studios with a localization manager and a git-native string pipeline.

The indie who paid a freelancer $4K to translate their Godot game into five languages doesn’t have any of that. They have a folder of .po / .csv / Unity .xlsx string files and a translated version handed back over email. They have zero budget left for LQA, so they either skip it or eyeball it in a language they can’t read — and find out it was broken when the Japanese reviews land.

LocProof is the standalone, no-TMS-migration audit that sits in exactly that gap: point it at your string files (source + translated), get a per-language risk report that maps directly to what will show up as a one-star Steam review. It’s not competing with Crowdin — it’s for the 90% of indie devs who will never adopt Crowdin. The incumbents do QA-as-a-platform-feature. We do QA-as-a-cheap-standalone-pre-launch-checklist.

4. Target market

• Primary customer: Solo devs and 2–6 person indie studios shipping text-heavy games (RPGs, visual novels, narrative, strategy, cozy-sim) to Steam, localizing into 3–8 languages on a <$10K localization budget. They use Unity, Godot, GameMaker, or Unreal and manage strings in .po, .csv, .xlsx, .json, or engine-native tables.
• Why they buy (their words): “I paid for the translation but I can’t read Japanese, so I have no idea if it’s actually good or if it’s going to get me review-bombed.” Broken translations, truncated buttons, and untranslated placeholder strings are, per LQA guides, the exact things that “prevent player backlash at launch” — and post-Aug-2025 that backlash is visible in the score.
• Rough TAM reasoning: ~14,000+ games ship on Steam per year; a large and growing share localize into multiple languages (13% of a 3,000-channel creator network already pay for pro localization, another 36% experiment). Even a conservative 5,000–8,000 games/year that localize and would pay for a $79–$249 pre-launch audit is a $1–2M/year serviceable slice for a solo tool — plus DLC/patch re-audits and adjacent software/app localization later.
• Why now for them: The Steam Aug-2025 change turned “eh, the translation is probably fine” into a scored, per-language liability they can no longer hide. The fear is fresh and dated.

5. Product sketch (MVP)

• Drag-in string files (.po, .csv, .xlsx, .json, Unity/Godot tables) — source language + one or more target languages. No account migration, no TMS.
• Truncation & overflow report: checks translated strings against font metrics and per-string length/width budgets you set (e.g. “this is an 8-char button”) and flags every string that will overflow or clip.
• Placeholder & variable integrity: catches {player_name}, %d, {0}, rich-text tags, and escape sequences that got dropped, reordered, or mangled in translation — a top source of runtime crashes and gibberish.
• MT-smell + glossary/lore drift: LLM pass that flags strings that read like raw machine translation, contradict a glossary you upload (character names, item names, key terms), or break tone/register (the “pirate talking like an HR manager” problem).
• Per-language Steam-risk report: a ranked list — “these 40 strings are what will get you a one-star JP review” — with severity, suggested fix, and an export (CSV/PDF) you hand to your translator for a paid fix pass.
• Re-audit on update: re-run after a patch/DLC and diff only what changed, so live-ops indies don’t re-pay for the whole game.
• Language coverage report: which strings are still untranslated / fell back to English per language.

6. AI angle — what’s load-bearing

Two halves. The deterministic half (placeholder integrity, font-metric truncation, untranslated detection) is plain code and doesn’t need AI. The load-bearing AI is the linguistic-judgment layer that indies otherwise pay a human LQA tester for: is this string machine-translation slop? does it contradict the glossary? is the tone wrong for this character? does this idiom land or is it a literal calque? That’s the exact work automation “used to be unable to do” and now can do at a per-string cost of fractions of a cent. Remove the LLM and you’re left with lexiQA-lite — the deterministic checks alone are commodity and don’t justify the price. The AI is what lets a solo tool replace the $2K–$5K human QA pass an indie can’t afford.

7. Localization angle (if any)

N/A as a geography play — this is a global-first DevTools product; the customer is the English-speaking (or any-language) indie dev, and the “localization” here is the subject matter, not a go-to-market wedge. That said, the sharpest initial vertical is Japanese and Simplified-Chinese output, because those are the highest-revenue, most-review-punishing target languages for Steam RPGs — lead with “don’t get review-bombed in Japanese” rather than a generic 30-language pitch.

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

• Pricing: Usage/credit + light subscription.
  • Pay-per-audit: $79 (one language) / $199 (up to 5) / $349 (up to 12) per full-game audit — priced as “1–2% of your localization spend to not get review-bombed.”
  • Studio subscription: $39–$99/mo for unlimited re-audits, glossary storage, and patch-diff runs — the live-ops / early-access crowd who ship monthly.
• ACV: ~$250–$600 blended (most buy one launch audit + 1–2 update re-audits; a minority convert to subscription for early-access titles).
• Rough math to $1M ARR: ~2,500 games/year at a ~$400 blended ACV = $1M. That’s a low-single-digit share of the annual localizing-indie cohort.
• Rough math to $5M ARR: 4,000 paying games/year + 1,500 studio subscriptions at $69/mo ($1.24M) + expansion into app/SaaS-string localization audits (same engine, different file formats) and agency white-label (freelance localizers running LocProof on client work). $5M needs the subscription and agency legs, not just launch audits.
• Expansion path: launch audit → patch/DLC re-audits → studio subscription → agency/white-label seats → adjacent non-game software localization.

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

• Ride the exact fear. Post a plain-English teardown — “Steam now shows your Japanese review score separately. Here’s what breaks and here’s a free audit of your first language” — in r/gamedev, r/IndieDev, r/godot, r/Unity3D and the Steam developer forums. Offer the first-language audit free; charge for the rest.
• Cold-scan and cold-email. Steam’s upcoming-releases and recently-updated lists are public. Identify titles that just added languages (SteamDB tracks depot/language changes), run a free partial audit, and email the dev a 3-issue teaser: “found 12 truncated buttons and 4 broken {variables} in your German build — want the full report?” This is a named list with a demoable hook, not “content marketing.”
• Freelance-localizer channel. The translators indies hire are on Upwork/Fiverr/LinkedIn and want to look professional. Give them LocProof free to run on their own deliverables (it makes them look good) — they become a distribution army that pulls their clients in.
• Launch on Product Hunt + gamedev Discords (Godot, Brackeys-adjacent, Wishlist-focused server) with the “don’t get review-bombed” framing — the category (dev tools, AI agents in workflows) is currently over-indexed on PH.
• Content moat by example: publish anonymized “we found X in a shipped indie game’s JP build” breakdowns — catnip for the exact subreddits where the buyers live.

10. Build complexity — justification

Medium. The heavy lifting is file-format parsing (.po, .csv, .xlsx, .json, Unity/Godot/GameMaker string tables — each fiddly but bounded and well-documented) plus a font-metric truncation engine (render-width against a supplied font/size — deterministic, off-the-shelf font libraries). The linguistic checks are orchestrated LLM calls with structured output. No custom model, no training data, no game-engine runtime integration required for v1 (files in, report out). A technical solo founder ships a credible single-format v1 in ~8–10 weeks; a pair covers the top formats + the report UI in ~3–4 months.

11. Gating checklist

Gate	Pass?	Note
Legal in target market	✅	Processing a customer’s own string files; no scraping of protected assets required for the core product.
Ethical — no harm / dark patterns	✅	Helps devs ship better localization; reduces slop, doesn’t generate it.
Market exists (evidence above)	✅	Enterprise incumbents already sell this feature; indies are the unserved segment; Steam change is a dated demand catalyst.
1–5 person team can build this	✅	Files-in/report-out; no engine runtime, no custom ML.
Launchable with <$50K / ₹40L	✅	Off-the-shelf APIs + font libs; main cost is founder time and LLM inference.

All five pass.

12. Feasibility score

Axis	Weight	Score	Notes
Problem intensity	20	15/20	Real, money-losing pain, but felt acutely at launch/patch moments (episodic), not daily. Post-Aug-2025 it stings more, but many indies still rationalize skipping QA.
Demand evidence	15	12/15	Strong: incumbents charge for the feature, dated platform shift, documented cost wall and review-damage. Weaker on verbatim indie quotes begging for a standalone tool specifically.
Build feasibility	15	12/15	No research risk; the grind is format parsing and font-metric accuracy across engines. Bounded but real.
Distribution clarity	15	11/15	Named subreddits/Discords, a scannable public list (SteamDB), and a freelancer channel. Conversion math is estimated, not proven.
Revenue mechanics	15	11/15	Pricing anchors cleanly to existing localization spend; per-audit ACV is modest, so $5M needs the subscription + agency legs to carry it.
Time to first revenue	10	8/10	Free-first-language → paid-rest funnel can convert within weeks of a single-format v1; no long sales cycle.
Defensibility	10	5/10	Execution-and-focus moat. Checks are copyable; incumbents could unbundle a standalone tier. Moat accrues from indie brand, format coverage breadth, and a growing rules/glossary corpus.
Total	100	74/100

13. Qualitative modifiers

Founder-fit tags

technical-heavy (format parsers, font-metric engine, LLM orchestration) · content-heavy (the whole GTM is gamedev-community credibility and teardown content).

Key assumptions to validate (3–5)

1. Assumption: Indie devs will pay $79–$349 for a pre-launch audit rather than skip QA. How to test: Pre-sell 20 audit credits from a single r/gamedev + Discord post before building the full engine; ≥10 paid pre-orders = signal.
2. Assumption: A files-in/report-out tool covers enough of the market without engine-runtime integration. How to test: Poll 30 target studios on how they store strings; if >70% are in the top 4 formats, v1 scope holds.
3. Assumption: The LLM linguistic pass is accurate enough that its flags are trusted (low false-positive rate). How to test: Run it against 3 shipped games with known localization complaints and confirm it surfaces the real issues without drowning them in noise.
4. Assumption: The freelance-localizer channel actually pulls clients in. How to test: Give 15 Upwork/Fiverr localizers free access; measure how many bring a paying client within 60 days.

Risk flags

1. Platform dependency: The urgency leans on Steam’s review policy; if Valve softens or reverses the Aug-2025 change, the “fear” hook weakens (the underlying QA value remains, but the sales narrative loses its edge).
2. Incumbent unbundling: Crowdin/Gridly/lexiQA could ship a cheap standalone indie tier and erase the wedge. Speed, indie brand, and format-coverage breadth are the only defenses.
3. Commoditization by model vendors: As frontier LLMs get better at “just translate this game correctly,” the prevention (good MT) could shrink the detection market. Counter: the report/risk-framing and engine-format integration are the durable value, not the raw LLM call.
4. Episodic buying: A one-shot launch audit is a low-frequency purchase; without the subscription/agency legs, LTV stays thin and CAC has to be near-zero (hence the community-led GTM).

14. Structured verdict

Score:                  74/100
Verdict:                GO
Confidence:             Medium
Best-fit builder:       Technical solo founder / two-person team, ideally with gamedev or localization background and community credibility
Time to revenue:        6–10 weeks (single-format v1 + free-first-language funnel)
Capital to launch:      ₹4–8 lakh ($5–10K) — mostly founder time + LLM inference
Top 3 assumptions to validate first:
  1. Indies will pay $79–$349 per audit — pre-sell 20 credits from one community post before building.
  2. Files-in/report-out covers the market — poll 30 studios on string storage; need >70% in top 4 formats.
  3. LLM flags are trusted, not noisy — run against 3 games with known localization complaints and check signal-to-noise.
Kill criteria:
  - Abandon if <10 paid pre-orders come from the first 2,000-impression community teardown post.
  - Abandon if the LLM linguistic pass can't beat a >30% false-positive rate on flagged strings after two tuning passes (devs will stop trusting it).
  - Abandon if a major TMS ships a $0–$99 standalone indie audit tier before your v1 and captures the subreddits.

15. Next step — 1-week validation sprint

• Day 1–2: Write the teardown post (“Steam now scores your Japanese reviews separately — here’s exactly what breaks your localization and how to catch it”). Build a dead-simple landing page with a “reserve an audit credit — $49 early-bird” Stripe button. No product behind it yet.
• Day 3–4: Drop it in r/gamedev, r/godot, r/IndieDev, one large gamedev Discord, and the Steam dev forum. DM 20 devs whose games recently added a language (via SteamDB) offering a free manual mini-audit of 50 strings in exchange for a call.
• Day 5: Decide. Go if ≥10 paid $49 reservations OR ≥5 devs on calls say “yes, I’d pay for this and here are my string files.” No-go if the post gets impressions but the Stripe button gets <3 clicks — that means the pain is acknowledged but not paid-for, and it’s a VALIDATE-at-best, not a GO.

The falsifiable result: paid pre-orders, not upvotes. Nodding-along is not willingness-to-pay.