Localization Without Repository Access: A Practical Guide
Localization Without Repository Access: A Practical Guide

You can localize a product without giving anyone access to your repository. Treat language files as a separate asset layer: export source strings, run translation and validation outside the codebase, and hand back packaged files that a developer drops in. The repo stays closed, and the only thing that crosses the line is a reviewed file.
This guide covers when that approach makes sense, four ways to do it, the mistakes that break it, and how a small team can run it with a short checklist.
TL;DR
- Repository access is a convenience for localization tools, not a requirement. Source strings can travel as files and come back as files.
- The approach works when your strings are separated from code, use placeholders instead of concatenation, and carry notes for translators.
- Validate before delivery: placeholder checks, format checks and an error-typology review keep manual QA short.
- Packaging matters as much as translation. Send back files in the formats your platforms expect (JSON, iOS .strings, Android XML, YAML, MP3/WAV).
- Arkian is built for this model: no repo access, no full translation management system (TMS), delivery-ready packages for small teams.
Table of Contents
- Why teams want localization without repo access
- Four ways to localize without touching the repo
- What your source files must get right first
- A workflow for small teams, step by step
- Quality control without a TMS
- Formats: what to ask for when files come back
- Our perspective: the repo is the wrong place to start
- When this approach is not the right fit
- Where Arkian fits
- FAQ
- Sources
Why teams want localization without repo access
The usual localization setup asks you to connect a tool to your Git host. It then opens pull requests, syncs branches and watches for changes. That works for a large engineering organization with a dedicated localization manager. For a small team it often creates more problems than it solves.
Three situations come up again and again:
- Security and ownership. A founder, a client or a security policy says nobody outside the core team touches the source. An agency may work on a client’s app without ever being granted repo permissions.
- No developer bandwidth. Reviewing automated pull requests, resolving merge conflicts in locale files and babysitting a sync is a job. Small teams rarely have someone for it.
- Content that is not in the repo. App store listings, voiceover scripts, onboarding audio and metadata often live in documents, not code. A repo integration never sees them.
The simplest answer is to move the exchange point. Instead of the tool reading your repository, your team hands over an approved source file, and gets back a package.
Four ways to localize without touching the repo
There is no single method. Each fits a different constraint.
1. File-in, file-out production
You export the source strings from your project (a JSON file, an iOS .strings file, an Android strings.xml, a YAML file), upload them to a production service, and download translated files for every target language. A developer reviews the diff and commits the result. This is the model we recommend for most small teams, because the repository never leaves your control and the handoff is a single, inspectable artifact.
2. Local command-line tooling
Developers can also run tooling on their own machine. Open-source CLIs such as Multilingual CLI scan a project for user-facing strings, extract them into i18n files and can optionally translate them through a machine translation provider. Its documentation lists over 15 translation methods, 12 of them free, and support for formats such as JSON, PO and XLIFF. Nothing is shared with a third party’s repo integration, but the work still sits with one of your developers, and quality control is up to you.
3. Decoupled watch mode
Some CLI tools use a watch mode and local storage adapters so translation runs in the background and only touches the repository when you are ready. As the project’s documentation describes, this effectively separates the translation process from the development cycle. It suits teams with a developer who likes to own the pipeline.
4. In-place patching of packaged apps
The extreme case is when you have no source at all, only a compiled application. For Electron apps, electron-live-i18n loads translations in place and runs a local translation server, so a packaged app can be translated with no rebuild and no source code. It is clever, and it comes with a cost: modifying a signed bundle can invalidate its digital signature, so it is a tool for personal use and testing rather than a release channel. If you do own the product, a clean strings file is a much safer route.
| Method | Needs repo access | Needs a developer to run it | Best for |
|---|---|---|---|
| File-in, file-out production | No | Only to commit the result | Small product teams, agencies, content creators |
| Local CLI | Runs on your own checkout | Yes | Developer-led teams who want control |
| Watch mode with local storage | Only when you choose to merge | Yes | Continuous work on a single codebase |
| In-place patching | No source at all | Yes | Packaged apps you do not own the code for |
What your source files must get right first
Removing the repository removes a safety net: the translator, or the automation, cannot read your code to guess what a string means. The file itself has to carry that context. Most failures in this model come from five avoidable problems.
Separate language-neutral data from presentation
Internationalization specialists have long advised storing and communicating language-neutral data, then applying formatting for dates, numbers and plurals at the client or at request time. The Unicode standard for locale data, LDML and CLDR, is the shared reference. When your files hold clean values and your app formats them per locale, translators never have to touch a date format string.
Never concatenate strings
If your app builds a sentence from fragments, such as “By proceeding you accept” followed by a separate “Terms of Service” link label, you force English word order onto every language. Mozilla’s localization best practices recommend a placeholder inside one complete sentence, so a translator can move the link wherever the target grammar needs it.
Write notes for translators
The same guidance says to explain variables and ambiguous terms in the source file, because translators often work without the user interface in front of them. Is “Post” a noun or a verb? Is {count} always more than one? A one-line note answers it before it becomes a wrong translation.
Protect placeholders
A translated string that drops {name} or turns %d into % d crashes or shows garbage. Automated placeholder checks should run before any file is delivered. We have written about how small teams catch broken tokens in CI, and the same checks apply when no repository is involved.
Keep a glossary
Product names, feature names and terms you never translate should be defined once. A short localization glossary removes a large share of review comments.
A workflow for small teams, step by step
Here is the sequence we see working when nobody outside the team has repo access.
- Freeze an approved source. Pick the exact English (or source-language) file you want translated. Treat it as the single source of truth for this release.
- Export in your native format. JSON for web and React apps, .strings for iOS, XML for Android, YAML for frameworks that use it. Do not convert to a spreadsheet and back.
- Add context. Include translator notes, character limits where the UI is tight, and the glossary.
- Run production. Translate the strings, and generate any companion assets: voiceover scripts, text-to-speech audio, store metadata.
- Validate. Check placeholders, valid file syntax, key parity with the source and length limits.
- Package. Deliver one folder per locale with predictable names, so a developer can copy it into the project without renaming anything.
- Review the diff, then commit. A developer looks at what changed and merges it. This is the only moment the repository is involved, and it stays in your hands.
If you ship often, add version discipline. Matching each translation package to the build it belongs to, as covered in our note on translation file versioning with Git SHAs, prevents the common mix-up where an old translation file ships with a new build. And skipping unchanged strings on re-upload, described in packaging translations for release, keeps repeat runs fast and cheap.
Quality control without a TMS
A TMS bundles translation memory, review queues and reporting. You can live without it, but you cannot live without a review method.
The most useful framework is an error typology. ISO 5060:2024 gives guidance for the human evaluation of translation output, covering human translation, post-edited machine translation and unedited machine translation. It uses defined error types and penalty points to produce a score and a quality rating, and it is designed with minimal complexity so that many kinds of users can apply it.
You do not need to certify anything. Borrowing the idea is enough: have reviewers tag each issue as mistranslation, terminology, grammar, placeholder or style, instead of leaving free-text comments such as “sounds off.” Post-editing guidance from the Asia-Pacific Association for Machine Translation makes a similar point: results depend less on the tool and more on the quality of the specifications you give. Structured feedback shortens each review cycle because the next run knows exactly what to fix.
A practical review split for a small team:
- Automated checks: syntax, placeholders, missing keys, duplicated keys, length.
- Native-speaker pass on high-visibility screens: onboarding, payment, error messages, store listing.
- Spot check on the rest: sample 10 to 20 percent of strings and tag issues by type.
If your team wants a repeatable setup, our localization project templates show how to build QA into the process instead of adding it at the end.
Formats: what to ask for when files come back
The point of this model is that the output drops straight into your project. Ask for the formats your platforms use natively:
- JSON and TypeScript for web apps and many cross-platform frameworks. See how we handle JSON language files and TypeScript language files.
- iOS .strings for Apple platforms, covered on our page for iOS .strings files. If you work with Xcode exports, the XLIFF workflow explains the stages and common Xcode fixes.
- Android XML for native Android apps: Android XML string files.
- YAML for Rails-style and static site setups.
- MP3 and WAV if you need spoken versions of your content.
Folder layout is not cosmetic. A predictable structure, one folder per locale with consistent file names, is what lets a developer merge without thinking. We document ours on the multilingual output folder structure page.
Web teams should also think about what sits around the strings. Localized pages need correct language signals for search engines, and some teams handle that by automating hreflang tags in CI/CD so they regenerate whenever content changes.
Our perspective: the repo is the wrong place to start
We built Arkian around a simple observation: for small teams, localization is a production problem, not a collaboration problem. Most tools begin by asking you to connect a repository, invite translators and configure a workflow. That is a lot of setup before a single string is translated.
Our approach starts at the other end. You bring an approved source. We produce the multilingual scripts, the voice output, the metadata and the structured language files, validate them, and package them so they are ready to review and release. There is no repository to connect and no TMS to administer, and that is deliberate.

We think this fits because the people we work with, small product teams, developers, content creators and agencies, have a clear finish line: a set of files that go into a release. They do not need a permanent localization department. They need the output, organized, and they need to trust it. Our work with the Quiet Harbour app is the clearest example: the aim was a coherent localized product experience across several languages, built from files rather than from repo access. You can read the details in the Quiet Harbour case study.
The trade-off is honest: without a repo connection, a human has to commit the result. We consider that a feature, because the final merge stays with the people who own the code.
— Arkian
When this approach is not the right fit
File-based production is not for everyone. Be realistic about these cases:
- Strings change daily and several developers commit constantly. A continuous integration setup with a local CLI may suit you better, since the sync is part of your daily flow.
- You need a large in-house translator community with shared translation memory and live collaboration. That is what a full TMS is for.
- You do not own the source. If you only have a compiled app, patching tools exist, but weigh the signature risk before shipping anything modified.
For releases, store listings, new market launches and audio or video localization, the file-in, file-out model usually wins on speed and simplicity.
Where Arkian fits
If you want the repo-free workflow without building it yourself, Arkian covers the full chain: localization strings, multilingual voice production, metadata production and structured packaging. The pricing is published on our pricing page: a membership at 19.00 CAD per month, or one-off credit packs at 29.00 CAD (Starter), 79.00 CAD (Pro) and 249.00 CAD (Studio). Not sure whether you are the right fit? See who Arkian is for. For app store text specifically, start with App Store localization without manual file work.

FAQ
Can I localize an app without giving a vendor access to my GitHub?
Yes. Export your strings file, send it for translation and validation, and commit the returned files yourself. The vendor only ever sees the file you chose to share, and your developer controls the merge.
Do I need a translation management system?
Not for a small team with a defined release cycle. A TMS is valuable for large, continuous, multi-translator programs. If your need is to turn an approved source into delivery-ready language files, production plus validation and packaging covers it with far less setup.
How do I keep translations from breaking my app?
Use placeholders rather than concatenated strings, and run automated checks for missing keys, altered tokens and invalid syntax before you commit. Review the diff in a branch, and build once before merging so a broken file fails early.
Is it safe to patch a packaged app with translations?
It is risky for anything you distribute. Patching tools that load translations into a packaged app can invalidate its digital signature, so use them for testing or personal use. If you own the product, translate the source strings and ship a normal build.
Sources
- NagusameCS/Multilingual, CLI for extracting and translating strings
- electron-live-i18n, in-place translation of packaged Electron apps
- Unicode LDML (tr35) and CLDR locale data
- Mozilla localization content best practices
- ISO 5060:2024, evaluation of translation output
- AAMT, post-editing guidance
- Automating hreflang in CI/CD