A button labelled “Continue” can mean “save and move on,” “start a trial,” or “confirm a payment.” Without context, even an experienced translator has to guess, and a polished guess can still send a user down the wrong path.
Sourcing software localization translators means finding people who can work with product language, string constraints, and development workflows, then giving them enough context to make sound choices. A native speaker isn’t automatically a skilled UI localization linguist. The right person also knows when a short string is ambiguous, how to preserve variables, and how to flag a source problem instead of quietly translating around it.
The hiring decision isn’t just freelancer versus agency. You also need to decide which locales to cover, what material to test, who reviews the work in the product, and how translated strings get back into your build. This guide walks through those choices, with a practical test and handoff checklist you can adapt to your team.
What you’re actually sourcing when you hire for software localization¶
A software localization translator adapts product language to a target locale and interface context while preserving meaning, usability, and the technical structure of each string. Translation is one part of the work. A localized product also needs strings that fit the interface, follow the product’s terminology, and behave correctly when variables or plural forms appear.
“Locale” means more than a language label. Your brief should identify the target language and the regional or market variant you need, such as the variety of Spanish your users expect. The dossier’s research notes that language and locale need to be distinguished, but the cited W3C page could not be verified; use your product’s actual market requirements rather than treating a language name alone as a complete specification.
A good candidate doesn’t need to be a developer. They do need to understand that a UI string may be displayed beside a control, inside an error message, or in a narrow mobile screen. The same English word can require different translations depending on platform and context. Apple’s WWDC23 session gives “tap” as an example of wording that may need to change for a Mac context, and describes string metadata such as keys, default values, comments, and string tables (Apple’s String Catalog session).
The distinction matters because a software localization translator is solving several linked problems:
- Meaning: What action or information does the string express?
- Use: What does the user see or do at this moment in the flow?
- Fit: Does the translated string work in its component and tone?
- Consistency: Does it use approved terms and match existing product language?
- Technical safety: Are placeholders, tags, IDs, and resource structures preserved?
- Reviewability: Can a developer or reviewer trace the translation back to the source string?
Source text quality affects all six. A bare string such as “Open” can describe a menu, a file, an account, or a status. A glossary helps with terminology, but it can’t tell a linguist which meaning the product intends. Screenshots, comments, and descriptive IDs reduce that ambiguity before it turns into a series of assumptions.
Mozilla’s localization guidance captures the priority in a short phrase:
“Meaning is everything.”
That principle gives you a better hiring signal than literal similarity to the English source. Ask candidates to explain a translation choice, especially when they change the sentence structure to make the target language clear. A linguist who can preserve meaning while making the UI sound natural is doing the job; a linguist who only mirrors source wording may not be.
The work also differs by product type. A mobile app may need short labels, permission prompts, and store descriptions. A SaaS product may have dashboards, notifications, help content, and continuous updates. A game may need narrative voice and dialogue alongside menus. The mobile app localization guide and SaaS localization overview help you map those content types before you write a job brief.
Define the scope before you look for candidates¶
A sourcing brief should tell candidates what they’ll translate, for whom, in which locale, and through what workflow. A vague request for “software translation” attracts proposals that may not match the real work. A clear scope helps you compare candidates on the same task rather than on promises.
Start by describing the product and users in plain language. Include the platform, key user journeys, tone, and any terms that must stay consistent. Say whether the project includes only UI strings or also store listings, onboarding emails, help articles, release notes, and support content. A translator experienced with interface copy may not be the right person for marketing content, and the reverse is also true.
Then document the operational details:
- Locale: Name the target language and regional variant that fits your users.
- Content: Describe the strings, screens, and related material in scope.
- Source format: Specify resource files, localization platform, spreadsheet, or another format.
- Context: Explain what screenshots, comments, or product access the linguist can use.
- Technical rules: List placeholders, markup, character limits, and string-ID conventions.
- Review: Name who answers language questions and who checks the result in the product.
- Change flow: Explain how updated strings are identified and how revisions are delivered.
Technical context is not optional decoration. Apple’s String Catalog guidance recommends comments that explain where and how strings appear. The session puts it directly:
“We recommend adding comments to strings in order to help resolve ambiguities for the translator.”
Apple’s WWDC23 String Catalog session
A comment can distinguish “Open” as a verb from “Open” as an adjective. A screenshot can reveal whether a phrase labels a control or explains a step. The person who knows that detail is usually a product designer or engineer, not the translator. Assign someone on your team to answer questions quickly so candidates aren’t forced to infer product behavior from English alone.
Choose files that preserve structure. Android recommends keeping most UI content in resource files separate from application logic (Android’s localization guidance). Sending source code to a linguist can expose irrelevant material and make accidental edits more likely. Extracted resources give the translator the strings they need while leaving product logic with engineering.
Ask engineering to retain stable, descriptive string IDs. Mozilla explains that IDs and variables form a contract between developers and localizers, and that an ID should change when the meaning or tone of its text changes (Firefox localization overview). A short ID such as ok can be unclear when the same label occurs in different contexts. A descriptive identifier gives reviewers and translators a better clue about the string’s use.
Briefing checklist
| Brief item | What to provide | Why it matters |
|---|---|---|
| Locale and audience | Target variety, market, and user profile | Prevents a language-only assignment from hiding market differences |
| Product context | Platform, user journey, and screen or component | Helps the linguist choose the right meaning and register |
| String metadata | IDs, comments, screenshots, or mockups | Resolves ambiguity before translation |
| Terminology | Approved glossary and style guidance | Keeps labels and product concepts consistent |
| Technical rules | Placeholders, markup, variables, and constraints | Protects functionality while allowing grammatical phrasing |
| Delivery and review | File format, reviewer, questions channel, and change process | Makes it possible to return usable work and resolve issues |
A glossary should define product terms, not just collect preferred translations. Add the concept, approved term, disallowed alternatives, and a short explanation of where the term appears. Mozilla recommends consistency with product style guides and approved terminology (Mozilla’s localization style guide). Teams without an established guide can start with a small list of product-specific terms and expand it as reviewers resolve real questions.
Choose a freelancer, an agency, or a tool-supported workflow¶
The right sourcing model depends on how much coordination your team can handle. A freelancer gives you direct contact with the linguist; an agency can coordinate a broader team; a tool-supported workflow can help with specific parts of document or file review. None of those options removes your responsibility to provide context and validate the result.
When a freelance software localization translator fits¶
A freelance translator can be a strong choice when you need a direct relationship with the person doing the work, can provide clear context, and have someone available to review language and product behavior. You can discuss a terminology choice with the linguist who made it rather than sending questions through several layers.
Check whether the freelancer has worked on software interfaces in your content area. “Technology translation” can mean product manuals, contracts, marketing copy, or UI strings, and those skills don’t always transfer without friction. Ask for examples of relevant work that the candidate is allowed to share, then discuss how they handle unclear source text, short labels, placeholders, and feedback.
A freelancer may be less suitable when your team has no time to manage questions, needs several locales coordinated together, or expects continuous work but has no process for managing changing strings. Those problems don’t make freelance translation a poor option; they mean your team must provide project coordination or source it elsewhere.
When an agency makes more sense¶
An agency may fit a project that needs coordinated linguists, editing, linguistic QA, or management across multiple locales. Ask what work the agency performs itself and what it assigns to partners. The word “agency” doesn’t tell you whether a named linguist will handle the strings, whether a separate reviewer is included, or who has authority over terminology decisions.
Request a workflow diagram or plain-language description of how a string moves from source to translation, review, and delivery. Clarify who handles translator questions, who approves changes to the glossary, and whether in-context review is part of the scope. Ask for a named contact for project questions and a clear explanation of what happens when a release changes after translation starts.
An agency can coordinate work, but your product team still needs to explain features, confirm intended behavior, and resolve source ambiguities. A project manager can’t reliably infer whether “account” means a user profile, a financial record, or an organization account. Keep a product owner available for language questions.
Where a tool-supported workflow helps¶
Some projects include documents such as user manuals or help files alongside interface strings. ChatsControl is an option for those document tasks: upload a DOCX or PDF, then review the translated Word file with the source and translation displayed side by side. The bilingual review view can help a reviewer inspect wording without switching between separate files, while the built-in checks flag issues such as changed numbers, names, terminology, and omissions. The product is a document-translation tool, not a CAT tool or translation-management system, so it doesn’t replace string-level project management or a localization platform. See ChatsControl.
Keep the tool choice separate from the translator choice. A document workflow may help you review a manual or other file, but it doesn’t tell you whether an interface label fits a button or whether a translated flow works in the product. UI string sourcing still needs a qualified linguist, contextual handoff, and linguistic QA.
For work that requires terminology control across repeated material, compare the capabilities of your localization platform before you hire. The Lokalise versus Crowdin comparison and the CAT-tool comparison can help separate platform features from the linguistic work you need to source. A platform can store strings and help organize review; it can’t make an unclear source string clear without context.
Build a translation test that reveals how candidates work¶
A translation test should resemble the actual product work without becoming an unpaid production assignment. Use a small, representative sample and give every candidate the same context. Evaluate the reasoning and technical handling, not just whether a reviewer prefers one sentence.
Include a mix of string types:
- A short button or menu label that depends on context.
- An error message that explains what happened and what the user can do.
- A string with a variable, such as a name, number, or date.
- A quantity message that changes with a count.
- A term from your glossary or an unresolved terminology question.
- A string with a character constraint or markup, if those occur in the product.
A test made entirely of ordinary sentences won’t show how a candidate handles the risks that make software localization distinct. Android’s string-resource documentation explains that plural choices depend on grammatical need, not merely on the numeric value, and recommends relying on the translator to know which distinctions the language requires (Android string resources). Unicode CLDR describes plural categories such as zero, one, two, few, many, and other, with “other” required; the categories that matter vary by locale (Unicode CLDR plural rules).
A test can include a few example count values and ask the candidate to explain what forms they would expect and why. Don’t grade the candidate on reproducing a fixed English pattern. Grade whether the linguist identifies the grammatical requirement, preserves the intended meaning, and raises a source-design problem when the source doesn’t support a clear translation.
Variables need a similarly deliberate check. Mozilla advises that variables shouldn’t be translated, but may move within a string when the target-language grammar requires it (Mozilla’s localization style guide). A candidate who moves a placeholder to make a sentence natural may be right, provided the file format permits that movement and the variable stays intact. Give candidates your actual syntax rules rather than asking them to guess whether {count} or %1$s can be changed.
Score the test by category:
| Category | What a strong response shows |
|---|---|
| Meaning | The translated string communicates the intended action or information |
| Naturalness | The wording sounds like real product language in the target locale |
| Context use | The candidate makes use of screenshots, comments, and platform details |
| Terminology | Product terms match the glossary, or the candidate flags a conflict |
| Technical care | Placeholders, markup, and IDs remain safe and traceable |
| Judgment | The candidate asks a focused question when source meaning is unclear |
Separate language quality from product behavior. A linguist can produce a good translation and still need the interface tested for truncation, resource fallback, or an incorrect variable. A product reviewer can catch a button that behaves incorrectly but may not be qualified to judge naturalness in the target language. Give both types of review a place in your evaluation.
Don’t treat the test as a hunt for a single “perfect” phrase. Two natural translations may both work. Ask the candidate to explain a choice when the source permits alternatives, and pay attention to whether the reasoning is clear and grounded in the supplied context. A candidate who flags a genuine ambiguity is often giving you useful information about your source content, not failing the test.


For a more focused process, this guide to hiring post-editors explains why editing machine output requires a different skill set from translating from scratch. Use that distinction when deciding whether your project needs a translator, a post-editor, or both.
Evaluate UI judgment, technical care, and review skills¶
A CV and a sample translation won’t tell you everything about how someone will work with your team. Use a short structured conversation to check judgment, process, and communication. Give each candidate the same questions and note concrete examples rather than relying on general claims.
Ask how the translator handles these situations:
- A source string has two plausible meanings, and the screenshot doesn’t settle the issue.
- A developer changes the behavior behind a string but keeps the text identical.
- A placeholder must move to make the target sentence grammatical.
- A translated label doesn’t fit the component.
- A glossary entry conflicts with natural usage in the target locale.
- A reviewer rejects a translation but gives no explanation.
Strong answers describe a repeatable approach. A linguist might ask the product owner to confirm intended behavior, record a terminology decision, or suggest a source rewrite. Those actions show that the candidate can distinguish a language question from a product question and can make the uncertainty visible.
Discuss terminology management before production. Give candidates the glossary and style guidance you have, then ask how they’d handle a term that appears to be missing or contradictory. Mozilla recommends using approved product terminology and style guidance, while its guide stresses the need for the translator to understand the source meaning and references (Mozilla’s general style guide). A good workflow makes terminology decisions visible to the people who need to reuse them.
Check how the candidate prefers to receive context. Some linguists work well from resource files with descriptive IDs and comments; others need screenshots or access to a test build for in-context localization review. A useful discussion covers what the candidate can infer, what they need the team to supply, and how they will record unanswered questions.
Ask about review, too. Will the linguist explain a change, respond to a reasoned query, and update a term decision when the product owner clarifies meaning? Can they distinguish an issue in the target language from a change requested for product voice? Clear answers help you plan the relationship instead of discovering communication gaps during a release.
Keyboard shortcuts and access keys deserve a separate check if your product has them. Mozilla notes that command keys generally aren’t localized, but access keys may need attention if they don’t work with a target keyboard layout (Mozilla’s style guide). Ask candidates whether they have handled interface elements beyond ordinary prose, and make sure your engineering team identifies any product-specific rules.
The goal isn’t to hire a translator who claims to know every platform convention. You want someone who can explain what they can decide independently, what needs product input, and what needs technical validation. Those boundaries keep linguistic judgment from turning into silent engineering assumptions.
Prepare strings, placeholders, and a review path¶
A translator can’t protect a resource file if the source handoff hides its structure. Before assigning work, check that strings are extractable, IDs are meaningful, variables are documented, and the receiving team knows how to validate the returned files.
Android recommends separating most UI content from application logic and notes that the default resource file needs every required string; missing default strings can cause an app to fail in a locale without a matching translated resource (Android localization guidance). A translated resource file can also be partial and fall back to the default string. That fallback can hide untranslated content if the team checks only that a file exists, so validate completeness per locale as well.
Use a handoff that includes:
- The source resource file or approved export.
- String IDs and comments that explain use, audience, and limits.
- Screenshots or mockups for ambiguous or context-sensitive strings.
- A glossary, tone guidance, and any existing approved translations.
- Placeholder and markup rules, with examples of what must remain unchanged.
- A way to flag questions without editing application logic.
- Acceptance checks for missing strings, placeholders, numbers, and layout.
Stable IDs matter when text changes. Mozilla’s localization overview describes the ID and variables as a contract between the developers and localizers, and advises changing an ID when the text’s meaning or tone changes (Firefox localization overview). A changed meaning attached to an old ID can make existing translations look current when they no longer match the product. Change notifications should make clear which strings were added, edited, or removed.
Plan for interface growth before real translation begins. Microsoft recommends introducing pseudolocalization early and continuing to use it during development. Pseudolocalization replaces or marks text with test content so teams can spot issues such as clipping, missing resources, or font handling before translated strings arrive (Microsoft’s pseudolocalization guidance).
Microsoft gives an English-source expansion of 40% as a pseudolocalization heuristic and notes that some real translations can be 200% or even 400% longer; those figures are stress-test guidance, not predictions for every string or language (Microsoft Learn). Use the test to find fixed-width controls and layout assumptions, not to demand that every translated label fit an artificially expanded version.
Pseudolocalization can also add accents, other scripts, delimiters, or unique IDs to reveal whether the product handles character sets and resource mapping correctly. A test string marked with a unique ID can expose a hard-coded source string that would otherwise look like a translation. The method can reveal a technical defect before it becomes a linguistic complaint.
Technical checks and language review answer different questions. Microsoft cautions:
“While pseudotranslation can help discover many potential issues with localization, it isn’t a complete replacement for validating the translated application.”
Microsoft’s pseudolocalization guidance
A pseudolocalized build can’t tell you whether a translated error message is helpful, whether a term matches your product voice, or whether the user understands what to do next. Keep real translation, linguistic QA, and in-product review in the plan.
Common sourcing mistakes and how to prevent them¶
Most problems don’t start with a weak translator. They start when a team asks the linguist to solve product questions without product context, or when a team treats delivery of a translated file as proof that a localized feature works.
Choosing by native language alone. Native-language fluency is a starting point, not evidence of UI experience. Ask for relevant software work and test interface judgment. A candidate can write excellent general prose and still struggle with constrained labels, error messages, and product terminology.
Sending strings with no context. A word without a screenshot, comment, or descriptive ID may have several plausible meanings. Apple recommends comments to help resolve ambiguity, and Mozilla explains why descriptive IDs are more useful than short IDs such as ok (Apple; Mozilla). Fix the handoff before blaming a translator for a reasonable interpretation.
Treating placeholders as untouchable text. Variables should stay intact, but their position may change to fit the grammar. Document the exact syntax and let the translator reorder a variable where the format allows it. Then run a technical check that confirms the placeholder still exists and works.
Using one plural sample for every locale. A message that looks straightforward in English may require different forms in the target language. Android and CLDR both describe plural distinctions that depend on language (Android string resources; Unicode CLDR). Ask linguists to explain the forms their locale needs, and make sure engineering supports them.
Assuming a file is complete because it opens. Resource fallback can display default-language content even when a target resource is incomplete. Compare expected and translated keys by locale, then check the product for untranslated strings that the fallback may mask (Android localization guidance).
Using pseudolocalization as language QA. Pseudolocalization can reveal overflow and resource problems, but it can’t validate translated meaning. Microsoft’s documentation explicitly says translated applications still need validation (Microsoft Learn). Keep linguistic and in-product review in scope.
Changing source meaning without notifying the linguist. A string may keep the same English words while its behavior or tone changes. Track changes by ID and tell localizers when meaning shifts. Mozilla’s guidance treats IDs as part of the developer-localizer contract (Firefox localization overview).
Expecting a translator to catch every product defect. A linguist can report that text doesn’t fit or that a flow is unclear, but engineering must verify resource behavior, placeholders, and layout. Assign an owner for each kind of review so language questions don’t disappear into a general bug queue.
A useful final acceptance pass follows the string through the product: check completeness and placeholder integrity, review the language in context, and test the screens where text can expand or change user action. Keep terminology changes and source clarifications in the project record so the next release doesn’t repeat the same debate.
A practical sourcing sequence from brief to production¶
A sourcing process works best when each stage gives you evidence for the next decision. You don’t need a complicated vendor program to begin, but you do need a named owner for the brief, the test, and the product review.
- Map the content. List the interfaces and related content in scope, then identify target locales and platforms. Separate UI strings from manuals, support content, store listings, and marketing work.
- Prepare source material. Export resource files, preserve IDs and placeholders, gather comments and screenshots, and add the glossary and style guidance you already have.
- Choose the sourcing model. Decide whether your team can manage a direct freelancer relationship or needs agency coordination. Consider tool-supported document work only for material it actually handles, not as a substitute for a UI workflow.
- Invite comparable candidates. Give each candidate the same brief, sample, and explanation of the review process. Ask for relevant software experience and how they handle ambiguity and technical constraints.
- Run a representative test. Include short labels, contextual wording, variables, and plural behavior. Score each part separately and give candidates a chance to explain their decisions.
- Confirm responsibilities. Name the product contact, linguistic reviewer, technical owner, and person who approves terminology decisions. Agree how questions and changed strings will be recorded.
- Validate before release. Check resource completeness and placeholder integrity, review translated strings in the interface, and test the parts of the product that pseudolocalization or real text exposed as risky.
The sequence matters because late sourcing exposes problems that an early language review could have caught. Mozilla’s UI localization overview recommends reviewing mockups and copy early to identify cultural and technical issues before strings are frozen (Firefox localization overview). A translator can then help identify unclear wording while design and engineering can still change it without disrupting a finished release.
Don’t skip the pilot simply because a candidate’s portfolio looks strong. A small sample gives both sides a chance to check terminology, feedback style, and file handling before the full workflow depends on them. Keep the sample focused on representative strings and don’t ask for a large volume of unpaid work.
Set a route for questions before the first batch arrives. A translator should know where to flag uncertainty, who can confirm product behavior, and how the team will record a decision for future strings. Without that route, the linguist may make a defensible choice that conflicts with an unstated product rule.
FAQ¶
How do I evaluate a software localization translator?¶
Review work relevant to software interfaces, then use a short test with contextual UI strings, variables, and plural examples. Score meaning, naturalness, terminology, technical care, and how the candidate handles uncertainty rather than relying on literal similarity to the English source.
Should I hire a translator or a localization agency for UI strings?¶
Hire a freelancer when your team can manage context, questions, and review directly. Consider an agency when you need coordination across linguists or additional review and project management, but confirm who translates the strings and what review the proposed scope includes.
What should a software localization translation test include?¶
Include short labels, a context-sensitive string, an error message, variables, and a quantity message. Give candidates the same screenshots, comments, glossary, and technical rules, then ask them to explain any choices that depend on context or target-language grammar.
How do I brief translators on app UI strings and placeholders?¶
Provide the target locale, platform, string IDs, source resource file, comments, screenshots or mockups, glossary, tone guidance, and placeholder syntax. Explain which variables may move for grammar and which markup or resource rules must remain unchanged.
Can a translator work directly in our code?¶
Most UI translators should receive extracted resource files or work through an appropriate localization workflow rather than editing application logic. Android recommends separating most UI content from the app’s logic, which helps keep language work and code changes distinct: Android localization guidance.
Does pseudolocalization replace linguistic QA?¶
No. Pseudolocalization helps teams find technical problems such as clipping and missing resources, but it doesn’t judge the meaning or usability of real translated text. Microsoft says it isn’t a complete replacement for validating the translated application: Microsoft Learn.