Vietnamese localization pipeline, on autopilot.
Plug FAS into your repo, CMS or API. Every content change is detected, translated by AI, verified by native Vietnamese experts, and synced back, continuously, at any volume.
One pipeline, wired into your stack.
From a content change to a published translation, with no manual handoff, no copy-paste, no lost context.
Connects to what you already use.
Connect with an access token or app credentials, or call the API directly. FAS reads your resource files, keeps their structure, and writes translations straight back.
No connector for your stack? Use the REST API, CLI or webhooks and wire FAS into any workflow.
What happens on every change.
The mechanism behind the pipeline, stage by stage.
01Detect — only the delta
A webhook fires on push, merge or publish. FAS parses the file, diffs it against the last known state, and picks up only the keys that were added or changed, tracked by key and content hash. Nothing else re-enters the queue.
02Prepare — protect structure
Placeholders, variables and inline tags are locked so a model can never break them. ICU plurals are handled, and UI keys carry a length budget so translations still fit the button.
03Leverage — your TM & glossary
Every project draws on your own translation memory and termbase. Exact and fuzzy matches are reused, repetitions collapse, and locked terms are injected, so cost drops and terminology stays identical across releases.
04Translate — best of N models
Each segment is drafted by several engines, then a judge model and a reference-free quality-estimation score pick the best draft or blend the strongest parts. The output stays grounded in your TM, glossary and context. No single-vendor bias.
05QE gate — auto or human
Automated checks (placeholder integrity, ICU validity, length, forbidden terms) plus the QE score decide the route: high-confidence segments auto-approve; anything uncertain goes to a native linguist. You only pay humans where it matters.
High-confidence segments ship straight through.
06Human QA — in context
A native-speaker linguist reviews the routed segments with the key, screenshot and developer notes in view, then scores the delivery against MQM. High-stakes strings get a second reviewer. It is the same native post-editing behind our MTPE service.
07Sync — back into your stack
Translations are written back in the original format and delivered your way: a pull request on Git, a push through your CMS API, or over-the-air via the localization CDN, so mobile and web update with no redeploy.
The hard part isn't the draft. It's the verdict.
Any model can produce a translation. The engineering that matters is deciding which draft is actually right, or fusing the best of several into one. That arbiter is the core of the pipeline, and where FAS spends its intelligence.
A strong reasoning LLM reads the source and every draft, then keeps the best, or blends their strongest parts into one. Judged on semantic accuracy, fluency, terminology and format.
A quality-estimation model, such as COMET-QE, scores each draft against the source with no human reference. The highest score wins.
Compare the drafts to each other with semantic similarity (or BLEU / ROUGE). When two of three converge on the same meaning, trust the cluster.
Roughly 4× tokens per segment — three drafts plus a judge. We draft with cheap models and reserve a strong one for the verdict.
Drafts fire in parallel, not in sequence, so a segment waits on the slowest model — not the sum of all three.
If a provider errors or times out, the arbiter judges the drafts that returned instead of stalling the whole queue.
Wire it into CI in minutes.
Gate a release on localization: fail the build if strings are missing or QA is below your bar. The GitHub Action and CLI are in private beta with pilot customers.
# On every push, sync source strings to FAS on: [push] jobs: localize: runs-on: ubuntu-latest steps: - uses: ./.github/actions/fas-localize # shipped into your repo with: token: ${{ secrets.FAS_TOKEN }} source: locales/en.json gate: mqm>=90 # fail build if below # illustrative sample run $ fas push && fas status → 3 keys changed · queued to 12 languages ✓ 11/12 auto-approved · 1 in human QA · MQM 99
Built to keep up.
Event-driven and incremental, so it scales from a handful of strings to a catalogue of millions, without re-translating what has not changed.
See every language, every release.
Coverage, quality and cost in one place, so localization is measurable, not a black box.
Fast. Accurate. Secure.
Faster releases
AI drafts every change in seconds and routes only the uncertain segments to people, so a release never waits on translation.
Webhook-triggered · delta-only · ships with your release.
Accurate at scale
Placeholders, tags and ICU plurals are locked, your TM and glossary are enforced, and every delivery is scored against MQM with the error report attached.
Placeholder-safe · TM & glossary enforced · native review on what matters.
Secure by design
Your TM and glossary stay yours. Content is processed in isolation and never used to train public models.
NDA on request · access-scoped keys · full audit trail.
Built for content that never stops.
Pick your domain: the content that flows through the pipeline, the three pains we hear most, and exactly what FAS plugs in to fix them.
Fitted to your product, not the other way around.
Localization automation only earns its place if it drops into your exact stack, respects your security boundaries, and matches your quality bar. Every FAS deployment is scoped and hardened for the way you already work — a co-engineered integration, not a one-size-fits-all toggle.
Connectors, REST API, CLI or custom parsers wired to your repos, CMS, PIM and build. New file formats and edge cases are handled as first-class inputs, not afterthoughts.
No training on your data, encryption in transit and at rest, SSO over SAML 2.0 or OIDC with your identity provider, role-based access, and a dedicated deployment in the region you choose. NDA and DPA on request.
Your translation memory, glossary and termbase, with QE thresholds, routing rules and brand voice tuned to your domain — so "good enough" means exactly what you mean by it.
PR-based, CMS or over-the-air delivery, CI gates on your terms, a full audit trail, SLAs and a named integration engineer through onboarding and beyond.
What ships today, stated plainly.
Every FAS pipeline is a dedicated deployment scoped to your stack. Here is what runs in every deployment, what we set up with you during onboarding, and what is still in beta.
| Capability | Status | What that means |
|---|---|---|
| Delta detection, placeholder & ICU lock, TM + glossary | Included | Stages 01–03 above run in every deployment. |
| Best-of-N drafts with a judge model | Included | Claude, GPT and Gemini draft by default. DeepL, Google or Azure can be added with your own keys. |
| QE gate and automated QA checks | Included | Reference-free, LLM-based quality estimation plus placeholder, ICU, length and term checks. COMET-QE scoring can be added on request. |
| Native-linguist review with an MQM report | Included | FAS linguists review the routed segments, and every delivery comes with an MQM 2.0 quality report. |
| Delivery: pull request, CMS write-back, OTA / CDN, REST API, webhooks | Included | Includes CI status checks on GitHub, GitLab and Bitbucket. |
| No training on your data | Included | FAS never trains models on your content, and AI engines are used only under API terms that exclude it from training. |
| Connectors for the 12 platforms above | Set up with you | Built against each platform’s published API. The first sync into your own account is verified with you at onboarding. |
| SSO (SAML 2.0 or OIDC) | Set up with you | Connected and tested with your identity provider, such as Okta, Entra ID or Google Workspace, during onboarding. |
| Data residency & encryption at rest | Set up with you | Your dedicated deployment runs in the region you choose, on encrypted storage. |
GitHub Action and fas CLI | Private beta | Shipped to pilot customers inside their own repo. A public release on GitHub and npm is coming. |
| Fine-tuning a model on your TM | Roadmap | Today, adaptation is in-context: your TM matches, glossary and style guide go into every prompt. |
Figures in the example panels on this page (scores, percentages, costs and counts) are illustrative, not results from a named customer.
Specialized language services, scoped per project.
The same native linguists also take on focused projects outside the pipeline. Each one is scoped and quoted on its own.
-
Linguistic QA (LQA) and MQM scoring
Language quality assurance for translations you already have: native reviewers audit existing translations, vendor deliveries or machine output, and return a categorized MQM error report with a fix list.
LQA auditMQM error reportVendor & MT reviewFix list -
AI training data in Vietnamese and Southeast Asian languages
Speech data collection, audio data transcription, text annotation and LLM output evaluation, carried out by native linguists to your guidelines, scoped per project.
Speech & audio dataTranscriptionAnnotationLLM evaluation -
Voice-over and subtitling
Script translation and adaptation, subtitles checked against reading-speed limits, and native voice talent sourced for each project.
Script adaptationSubtitlesReading-speed QANative voice talent
Questions, answered.
Not sure it fits your setup? Tell us your stack and we will map the integration.
Talk to usDo I have to replace my current tools?
How does it stay in sync?
Is everything machine-translated?
What about placeholders and formatting?
Is my content used to train models?