Don't Build for One Language Only: Adding a Second Language to a Vibe Project
Translation is only the raw material: detection, translation order, a glossary, hreflang, support, and monthly maintenance decide whether a second language is growth or decoration — with a fictional funnel, 1000→860→640→380→210.

Let me draw the boundary first, so you don't get halfway through and realize you've read this before: the site already has a guide called "Your Vibe Project Deserves i18n: A Hands-On Route from Hard-Coded Strings to Going Multilingual" (vibe-project-i18n-guide, 6 October 2026), which covers the engineering half — when it's worth doing, how to get AI to sweep hard-coded strings into keys, picking an i18n library by framework, AI first drafts plus human proofreading, four pitfalls, and an acceptance checklist. That guide is about "how to produce the translations"; this one is about the other half — "once the translations exist, how do they actually reach the user": how the browser figures out what language someone speaks, what to translate first and what to leave for later, how translations keep up when a line of copy changes, what to do in launch week for the second language, and how translations quietly rot over six months. Together the two guides make one complete multilingual launch. The example product in this article, "Green Sprout Ledger" (a small budgeting app), and its author "A-Yuan" are fictional examples used to make the process concrete — not a real product or a real person. The funnel numbers in section six are a fictional sample too, and the text says so explicitly.
Here is the one-sentence conclusion up front: for a vibe project, adding a second language is never really about the translating — AI can translate a hundred UI strings in minutes. The hard part is letting someone who doesn't read Chinese go from opening your site all the way to paying, without getting stuck, confused, or suspecting the product is half-finished at any point along the way. Translation is just the raw material. Detection, prioritization, workflow, launch, and maintenance are the five things that decide whether a second language is growth or decoration.
1. First, Be Clear: Who Is the Second Language For?
Before you touch anything, answer one question: who exactly is this second language for? "The whole world" is not an answer — the whole world is not a user. A-Yuan's budgeting app started in Chinese only, and he wanted to add English because "English has the most users". That's true, but too crude to act on. There are three real sources for the decision. First, who is already looking at your site — check your access logs for the top countries and regions; if 8% of visits already come from Japan, Japanese beats English. Second, has anyone actually asked — has someone emailed, filed an issue, or sent a message asking "is there an English version"? One real person waiting beats a hundred imaginary ones. Third, where are you going to find new users — if you plan to launch on Product Hunt or post in English-language communities, then English is the working language of those channels, and there's nothing to hesitate about.
For most Chinese authors' vibe projects, English as the second language is the right call. English is the working language of Product Hunt, GitHub, and Hacker News, and it's also the language users everywhere tolerate best in an English product — a German user may not read your Chinese, but they can probably get by with the English version. The real reason to pick English isn't "English has the most users"; it's "English is the passport to overseas channels". And the reverse holds too: if you have no plans to go to overseas channels at all and only want to serve Chinese users, don't add it — once a second language is live, it's a permanent maintenance cost, and a language nobody uses is the most expensive decoration you can own.
There's one more rule that's easy to miss: add one language at a time. A-Yuan first wanted to ship English, Japanese, and Korean together, figuring AI translation was cheap anyway. Translation is cheap; everything after it is expensive: detection logic for three languages, three glossaries, three times the screenshot review, launch posts for three channels, user feedback in three languages. Add one language, run the whole chain from detection to maintenance once, and the next language is copy and paste. People who try to do too much at once usually end up with three half-finished languages and a pile of translation files nobody dares to touch again.
2. How a Language Gets "Recognized"
When a user opens your site, how does the system know which language to show them? The answer is a detection order with clear priorities, not any single signal. First priority is the user's last choice — if they manually switched to English last time, show them English this time and stop guessing. Store that choice in a cookie or localStorage so it sticks. Second is the browser language, navigator.language or the Accept-Language request header — the preference the browser states on the user's behalf, which is far more reliable than a guess. Third, and only third, is IP geolocation — and it can only ever be a hint, never a decision: people travel, students study abroad, and plenty of users are on VPNs, so the country an IP points to and the language its user speaks are often two different things. An IP tells you "this person might be in Japan"; the browser tells you "this person reads Japanese". Trust the latter.
Even after detection, don't rush to redirect. The worst experience is this: a user clicks your link, the page flickers, and they land on a version in another language with no obvious way back. The right approach is to show a visible but unobtrusive hint — a small banner at the top of the page — or to render in the detected language while keeping the language switcher impossible to miss in the top-right corner, so the user can switch back with one click. Automatic redirection is fine, but "one click to get back" is its precondition. Without that, an automatic redirect is locking someone in a room they can't leave.
The switcher itself deserves care. First, write each language in its own name: English, 日本語, Français, Español — not "English, Japanese, French" translated into your language. A Japanese user who doesn't read Chinese can't recognize the characters for "Japanese" in Chinese, but they recognize 日本語 at a glance. Second, don't use flags alone as the switcher: one language spans dozens of countries, one country speaks several languages, flags are inaccurate, and in politically sensitive regions they cause trouble. Flags can decorate; they can't be the only identifier. Third, put the switcher somewhere fixed: top-right on desktop, top of the menu on mobile, and once more in the footer. When users go looking for the switcher, they're usually already a bit frustrated — don't make them hunt across the whole page.
Finally, the fallback rule — "what happens when something isn't translated". Every real project has gaps: a new feature shipped before its translations caught up, an edge page whose key someone forgot to add. When a string is missing, the page should show the source-language original and log the gap in the background — never show the key name (like settings.profile.saveButton) and never leave a blank. Showing a key name tells the user "this product is broken"; showing the original at least lets them keep going. Decide the fallback rule on day one and write it into code; don't wait until a user sends you a screenshot asking what that line of gibberish means.
3. What to Translate First, What to Leave for Later
The order of translation doesn't follow file order, and it doesn't follow "shortest file first" — it follows the order in which a user walks through your core flow once. The order A-Yuan settled on for the budgeting app was: landing page, sign-up and login, onboarding, the core flow of recording an expense, billing and the payment page, emails and notifications, help docs. The logic is: translate the parts that make people stay before the parts that tell people about you. Users see the landing page first, then sign up, then use the core feature — wherever they get stuck is wherever they churn. No help doc, however beautifully translated, will save a user who can't understand a button on the sign-up page.
That order leads to a counterintuitive rule: don't launch the second language until the core flow is 100% translated. A half-translated page does more damage than an untranslated one: when Chinese and English buttons sit side by side on the same page, users don't think "this product is being translated" — they think "this product is half-finished". Pages that aren't done yet should stay out of the second language's navigation; for pages you can't route around (like legal terms), you can keep the source-language version for now, but put one line at the top in the target language saying "This page is not yet available in English", instead of pretending it's done. Honesty beats completeness: users can accept "not translated yet", but not "half translated and pretending otherwise".
Different kinds of copy deserve different standards. Buttons, error messages, and empty states — get those wrong and users hit the mistake immediately, so they're worth a human review. Marketing copy — headlines and selling points on the landing page — is worth a human polish too, because Chinese marketing lines translated literally often read like scam messages in English. Legal terms and payment-related copy are the special case: a single word can carry a different legal meaning, so don't let AI translate them and ship — a human has to review them, ideally a native speaker who knows the domain. The site's i18n guide already made this point, so I won't repeat it here; I'll only add one line: spend your translation budget where it matters, and where it matters is the hundred strings users see most often and where a mistake costs the most.
Translation completeness should be managed as a launch gate, not a feeling. A-Yuan's method is simple: a checklist, one tick per core-flow page, and the second language only ships when every box is ticked. Edge pages may carry a "translating" label, but only a few — if more than ten pages wear that label, you shipped too early. Once the gate is set, nobody on the team (even if the team is just you) gets to say "ship it now, we'll translate later", because nine times out of ten, "later" never comes.
4. The Translation Workflow: From Changing One Line of Copy to Shipping It
The real trouble with translation isn't the first time — it's the tenth. Translating a hundred strings the first time is an afternoon's work; the tenth time is three months after launch, when you've changed twenty strings, added three features, and removed an old page, and your translation files are full of old sentences nobody knows are still valid. So after the second language ships, what you really need to build is a workflow: a change to one line of copy travels from the source-language file, through translation, to the user's screen, with a rule at every step.
The process A-Yuan ended up with has just five steps. Step one: change copy only in the source-language file, and never quietly change what a key means — if a "Subscribe" button needs to become "Become a Member", don't reuse the old key and change its text; open a new key, because the old key's translations may still be sitting in other language files, and reusing it plants a landmine. Step two: AI drafts the translation, but only after the glossary is set — product names, core feature names, billing terms: fix the translations of twenty words first and write them down, so the AI translates against the table. The glossary is the highest-return item in the whole workflow: twenty words fixed, and 80% of "that's not how we translated this last time" never happens again. Step three: a human reviews the top hundred most-seen strings — buttons, errors, empty states, the payment page — ordered by how often users see them, not by file order. Step four: screenshot review — switch to the second language and click through the core flow from start to finish, looking for long translations that break the layout, untranslated Chinese, and sentences whose meaning changed in translation. Step five: ship with the release — language files live in version control, and the release checklist permanently includes a "translation sync" item that has to be ticked before shipping.
Three landmines sit inside this workflow, and any one of them will quietly degrade your translations. The first is translated brand names: product and feature names get casually translated by AI, so the name users see in a Chinese community and the name they see in the English UI no longer match — they can't even search for it. The rule is: brand and product names never get translated; that's the first line of the glossary. The second is numbers and units being changed: AI sometimes turns "100 yuan" into something else, or "helpfully" localizes a date format — numbers, currency, and dates belong to dedicated formatting tools (the Intl family), never to translation. The third is tone shifting wholesale: a friendly customer-service sentence comes back sounding like a command, or the other way around. Machine translation doesn't care about tone, so review tone explicitly: however your product normally talks to users, the translation should talk the same way.
One last word on who does what: AI is the assistant, not the owner. On a one-person vibe project, the owner can only be you — you set the glossary, you do the review, you click through the flow before release. AI saves you the typing time, not the judgment time. Projects that hand the judgment to AI as well see their translation quality slide visibly within three months — and when it slides, nobody can tell which string it started sliding from.
5. More Than Words: Dates, Currency, and Time Zones
Many people think multilingual means swapping the words into another language. Words are only half of it. The other half is the stuff that needs no translating but differs from country to country: dates, currency, time zones, number formats. Get those wrong and users are more confused than by a mistranslated sentence. Take 2026/11/15: to an American, is that November 15 or June 10? It depends on where they live — the US puts the month first, China puts the year first. The right approach isn't to guess; it's to use the platform's built-in formatting tools (like Intl.DateTimeFormat) and let the user's locale render the date while you only pass an accurate time value. Building date strings by hand is the most common self-inflicted wound in multilingual projects.
Currency is trickier, because it's not just a formatting question — it's a pricing decision. Your product costs 68 yuan; should the English version say $10 or ¥68? Saying $10 involves exchange rates and pricing strategy; saying ¥68 makes an American user wonder "is this even sold to people like me?" A-Yuan's approach was two steps: first, don't touch pricing at all — just localize how the money is displayed, with the currency symbol, thousands separators, and decimal points following the user's locale. Second, deal with pricing itself later, once there are real overseas paying users. Don't reverse the order: formatting is a technical problem you can change anytime; pricing is a business decision, and every change costs some trust from existing users.
Time zones have exactly one rule: store UTC, display in the user's time zone. The server always stores UTC; conversion to the user's local time happens at display time. Plenty of vibe projects store local time to save effort at the start, and when users in a second time zone show up, billing dates and reminder times fall apart — the rework costs ten times what storing UTC would have cost from day one. Number formats deserve the same treatment: whether it's 1,000.5 or 1.000,5, the decimal point and thousands separator are reversed in different countries, so hand that to Intl.NumberFormat and just make sure the number you pass in is correct.
Two more cases can wait for your first second language, but keep them on your radar. One is right-to-left languages — Arabic and Hebrew — where the whole interface mirrors: buttons, navigation, and reading order all flip, a job comparable to rebuilding the UI. If your second language isn't one of them, leave it alone for now, but choose wisely at selection time: prefer logical layout properties (start/end) over physical directions (left/right) so a future RTL pass costs less rework. The other is input methods and forms: search boxes, note fields, validation messages — places where users type and need to understand errors. Error messages are when users most need to understand what's written: get "password too short" wrong and users will retry, fail repeatedly, curse once, and leave. Form copy and error copy belong ahead of marketing copy in priority.
6. The Funnel: Of 1,000 Overseas Visitors, How Many Stay?
The numbers below are a fictional sample, used to make the losses along the "second language" chain concrete: suppose Green Sprout Ledger gets 1,000 overseas visitors in a month. Of those, 860 have their language correctly detected (86%; the other 140 either give no browser-language signal, get mislocated by IP, or haven't had a chance to choose yet on a first visit). 640 actually see the interface in their language (74.4% of those detected, 64% of the total; the 220 lost here hit pages mixing Chinese and English, or a switcher buried too deep to find, or an automatic redirect that jumped to the wrong language with no way back). 380 complete the core action — recording their first expense — in their own language (59.4% of those who saw the right language, 38% of the total). 210 are still using the app seven days later (55.3% of those who completed the core action, 21% of the total). Across the whole chain, only 210 of 1,000 overseas visitors stay. Every step's loss is accountable: 140 lost at detection, 220 detected but never shown the right interface, 260 shown the right interface but never finishing the core action, 170 finishing once and never coming back.
The most useful thing in these numbers isn't the 21% at the end — it's what the distribution of losses is telling you. Language directly causes 140 plus 220, or 360 lost visitors, which is 45.6% of all 790 losses: nearly half of overseas visitors leave over language problems before they ever get to use the product, and that chunk is recoverable by fixing translation, detection, and the switcher — the cheapest losses on the board. But the other 430 (54.4% of losses) are product problems: people who saw the right language and still didn't finish the core action, or finished once and never returned — proof that translation can't save a confusing core flow. After reading this funnel, the first thing A-Yuan did wasn't to translate another hundred strings; it was to fix the step in the expense flow where 260 people stalled. That's the point of the funnel: it tells you which step's losses are language debt and which are product debt, and the two debts get repaid with different tools. Don't use translation to pay a product debt.
One more rule for using the funnel: always split the numbers by language. Never average Chinese and English data together. A product might retain 40% of Chinese users and only 12% of English users — averaged to 26% it looks fine, while the English chain is already broken. Splitting by language is the first rule of analytics after a second language ships, and also the easiest one to let "the average looks okay" hide.
7. Launch Week for the Second Language
Translations done, detection tuned, funnel built — the second language can ship. But shipping isn't pressing a publish button and walking away; launch week has a few things that have to happen. First, search: every language needs its own URL (like /zh/pricing and /en/pricing), and pages should point at each other with hreflang so search engines understand "these are the same page in different languages, not duplicate content". Pages that switch language only through JavaScript are effectively invisible to search engines in the second language — if your English pages can't be found on Google, you haven't really shipped. List both languages' URLs separately in the sitemap, not just one set.
Second, the launch channels: the launch posts that week should be written in the second language. Posting on Product Hunt means writing in English; posting in a Japanese community means writing in Japanese. Don't post a Chinese announcement with "English version available" tacked underneath. Users who open a post they can't read won't click again to hunt for the English version. Rewrite the post's headline, screenshots, and selling points for the target language's users — the screenshots especially: an English launch post with Chinese UI screenshots is the most common rookie mistake, and it tells everyone "the English version probably isn't ready yet".
Third, support: in the first week after launch, users will come to you with questions in the second language. Translate the ten most-asked FAQ entries first, and make auto-replies answer in the user's language — never send a Chinese auto-reply to an English user. More important still, leave a feedback door open: one line at the bottom of the page, in the target language, saying "Translation problem? Tell us", with the simplest possible feedback channel attached. Users are your best proofreaders — they'll run into the untranslated strings and awkward phrases your screenshot review missed during real use, but only if you give them a way to speak up.
Fourth, watch the numbers: in launch week, check the language-segmented data daily — detection rate, arrival rate at the right-language interface, core-action completion, seven-day retention. When a number drops, look at which funnel step is leaking first instead of guessing "maybe the translation quality is bad". Launch week's numbers are the baseline for every optimization after; if the baseline is wrong, every judgment after it drifts with it.
8. Long-Term Maintenance: How Translations Rot
Shipping the second language is only the beginning; the real test comes after. Translations rot in three ways, and each one is common. The first: new features ship untranslated — the feature goes live, its translation doesn't, the page falls back to the source language, and users assume it's a bug and post screenshots asking "is this broken?" The second: old translations stop matching the interface — a button's meaning changes but its translation stays the old one, so users act on the literal wording and find it does something else entirely. The third is the sneakiest: an AI re-translation overwrites sentences a human already fixed — with no locking mechanism, a bulk re-translation pass restores the machine flavor to copy that was already proofread, and the quality slides without anyone noticing.
The defense isn't complicated, but it has to become a rhythm. Once a month, sweep three lists: missing keys (which new features still lack translations), stale translations (which copy changed meaning without its translation following), and translation issues users reported. Rank what the sweep finds alongside the bug list — don't create a separate "translation debt" document, because nobody reads separate documents; put it with the bugs and it gets fixed. And be honest about the maintenance cost: a second language isn't a one-time project, it's a fixed extra half hour to an hour per release — translating new keys, re-checking screenshots, ticking the release checklist. Accept that cost and it's sustainable; pretend it doesn't exist and it comes back in three months as a pile of rotten translations.
A final word on "language number N". Once the first foreign language works, adding a third genuinely gets easier: the detection logic exists, the workflow exists, the glossary has a template to copy. But easier isn't free: every language adds maintenance cost and support load. Whether to add a third language uses the same test as the second — is a real person waiting, is real traffic arriving? If not, keep the second language well maintained first. One language maintained well beats three half-finished ones.
9. Before You Ship, Run Through This Checklist
One, the second language has a named audience: at least one real user waiting, or overseas traffic you can already see. Two, one language at a time — run the whole chain of detection, switching, and maintenance once before adding another. Three, the detection order is user choice, then browser language, then IP; IP is a hint, never a decision. Four, any automatic redirect must offer a one-click way back, and the switcher sits fixed in the top-right corner and the footer, written in each language's own name. Five, missing translations fall back to the source-language original and log the gap — never show a key name, never leave a blank. Six, the core flow is 100% translated before launch, and untranslated pages stay out of the second language's navigation. Seven, the glossary fixes twenty words first, and brand and product names never get translated. Eight, AI drafts, a human reviews the top hundred most-seen strings, and a screenshot review walks the core flow in the second language — all three steps, none skipped. Nine, each language gets its own URL, hreflang points the pages at each other, the sitemap lists both, and launch posts and screenshots are in the target language. Ten, the maintenance rhythm is on the calendar: a monthly sweep of missing keys, stale translations, and user reports, with a permanent "translation sync" item on the release checklist. Ten boxes ticked, and the second language is genuinely live — a person who doesn't read Chinese can use your product from start to finish. That's the passing bar for multilingual.
Comments (0)
Related articles
One page should stand up on a phone, a tablet, and a computer. This guide follows MDN's Responsive web design, Using media queries, and the viewport meta reference: fluid HTML, the viewport tag, fluid grids and max-width, images that never burst their container, media query syntax, breakpoints set by content, mobile first, responsive type, testing capability instead of width, and a pre-launch checklist.
localStorage only stores strings and has no indexes. IndexedDB is a real database in the browser: structured data, far larger capacity, indexes, and transactions. Following MDN's Using IndexedDB, IDBDatabase, and IDBObjectStore: the five-step routine, opening, upgrades, keys, indexes, transactions, add versus put, get, cursors, ranges, and multi-tab upgrades.
You already call functions every day; this guide names what you have been doing. Following MDN's Functions, Arrow function expressions, and Rest parameters: declarations versus expressions, parameters and arguments, default values, rest parameters, spread syntax, return values, arrow function shorthand, the this trap, callbacks, and scope.