Flixu
For Product & Engineering

Your app in 22 languages. Without the fragmented toolstack that's killing your sprint velocity.

Developers push code. Flixu detects new strings, translates with your Glossary and Brand Voice applied, and commits translated files to a dedicated branch. Product Managers see which segments need review and which ones auto-approved. One platform. No separate translation agency, no manual export step, no merge conflicts.

What is Flixu for SaaS Teams?

SaaS teams typically manage localization across two disconnected workflows: developers handling JSON file extraction and a PM managing an external translation agency. Flixu connects those two workflows in a single platform — the GitHub App handles the pipeline, Brand Voice and Glossary apply automatically, and the LQA dashboard shows which segments need human review and which ones are already approved.

The Problem

By the time the translations come back, the feature has already been refactored.

The localization cycle in a SaaS product team follows the same pattern. A developer adds new strings to a feature branch. Someone extracts them — manually, or with a script that needs to be maintained. The strings go to a translation tool or an agency. Translations come back a week or two later. The developer merges them, discovers that the feature was already updated since the strings were sent out, and now the translations are stale.

Meanwhile, the TMS bot and the feature branch both wrote to the same localization file. The result is a three-way merge conflict that has nothing to do with the feature and takes forty minutes to untangle.

From the community:

"Our translation cycles are killing our sprint velocity."

"The TMS bot keeps creating merge conflicts in our i18n files."

"We need something Git-native, not another file upload tool."

"Spent 40 hours last quarter just on localization coordination, none of it actual translation work."

"Crowdin PRs and our feature PRs keep colliding."

The problem isn't the translation quality. It's the workflow model — a human-centric pipeline attached to an engineering process that runs faster than it can keep up with.

Translations commit to your repository when developers push code — on a branch that doesn't conflict with your feature branches.

The Flixu GitHub App watches your monitored file paths. When a developer pushes new or changed strings, the app detects them, runs the translation pipeline with your Glossary and Brand Voice active, and commits the translated files to a dedicated localization branch — structurally separate from your feature branches.

The feature PR and the localization commit never touch the same files at the same time. The three-way merge conflict that stops the sprint doesn't happen because the files are separated at the branch level, not just at the process level.

For teams shipping weekly or more frequently, this means localization stops competing with development for the same repository files. The German version of a feature ships when the feature ships — not two sprints later.

According to CSA Research, 76% of software buyers prefer products in their native language. That preference only becomes revenue if the localized version is ready on the same release cycle as English.

→ GitHub App setup and configuration: GitHub Integration

"Settings" is "Einstellungen" — not "Konfiguration" or "Optionen." Every time. Everywhere.

A SaaS product with hundreds of UI strings updated across dozens of sprints accumulates terminology decisions. Without systematic enforcement, the same UI concept appears as multiple German words across different parts of the interface. Users navigating from the onboarding flow to the settings panel to the help documentation encounter inconsistent vocabulary — and it signals, even if subtly, that the product wasn't built for their market.

Flixu's Glossary loads your approved terms as payload constraints before the language model generates output. "Settings" maps to "Einstellungen" because the constraint was specified before generation, not checked afterward. Variables and placeholders — {{user_name}}, {count}, <strong> tags — are extracted from the text before translation and re-injected into the output file. The translated file is structurally identical to the source; the developer doesn't fix broken placeholders.

Teams using pre-translation glossary enforcement typically find terminology inconsistency drops from 15–25% of reviewed strings to under 2%.

→ Glossary enforcement: Glossary Enforcement

Your PM doesn't need to speak Japanese to know which segments need review.

In a typical localization workflow, a PM reviewing translated output either trusts it because they can't evaluate it, or they ask a native speaker — which adds time and a coordination overhead. Without a structured quality signal, the review is either superficial or slow.

Flixu's LQA scores every segment across five dimensions automatically: Grammar, Accuracy, Terminology Consistency, Formatting, and Fluency. Segments above the threshold auto-approve. Segments below the threshold appear in the review queue with the specific failing dimension marked.

A PM can see that three segments scored below threshold on Terminology Consistency — which means a glossary term is missing or incorrect — without being able to read Japanese. The review focuses on the edge cases; the rest is already approved and ready to deploy.

→ LQA and quality reporting: LQA & Quality Assurance

How the CI/CD pipeline works.

For teams using the GitHub App, the pipeline runs automatically on push. For teams with custom CI/CD setups, the Developer API provides programmatic access to the same pipeline.

GitHub App workflow (recommended)

Install the app, configure monitored file paths and target languages, link the repository to a Flixu workspace project. From that point, every push to monitored files triggers translation. Translated files commit to the localization branch. The setup takes under 15 minutes.

Developer API workflow (for custom pipelines)

For teams using GitHub Actions or custom deployment pipelines, the API supports direct integration:

# Conceptual example — actual endpoints in the API documentation

curl -X POST https://api.flixu.ai/v1/translate \

-H "Authorization: Bearer YOUR_API_KEY" \

-H "Content-Type: application/json" \

-d '{

"file": "src/locales/en.json",

"target_languages": ["de", "fr", "ja", "es"],

"project_id": "your-project-id"

}'

The request runs the full translation pipeline — Pre-Translation Analysis, Glossary enforcement, Brand Voice application, Translation Memory retrieval, LQA scoring — and returns the translated content with scores per segment. Segments above threshold auto-approve; segments below are routed to the review queue.

→ Full API reference and authentication: Developer API

Developers, PMs, and Technical Writers in the same workspace.

The localization workspace supports the full product team without per-seat pricing that penalizes collaboration. Roles follow the platform's three-tier model: Admin (workspace configuration, billing), Project Manager (project setup, review, approval), Translator (string-level editing within assigned projects).

External reviewers — a regional marketing manager checking the Japanese launch, a native speaker verifying the French campaign — can be added as Translators scoped to their assigned projects without accessing global glossary configuration or other client workspaces.

The credit model charges for words translated, not for workspace seats. Adding a PM to the review queue doesn't change the invoice.

→ Team roles and access controls: Team Collaboration

Frequently Asked Questions

Does Flixu have a localization API for developers?

+

Yes. The Developer API accepts translation requests programmatically and returns translated content with LQA scores per segment. The GitHub App handles the repository integration automatically without requiring API calls — you configure monitored file paths and the pipeline runs on push. For custom pipelines, the API supports webhook-based triggering for async translation of larger batches.

How does Flixu handle JSON keys, variables, and placeholders?

+

The parser extracts only the translatable text values before the language model sees anything. JSON keys, HTML tags, Markdown syntax, and interpolation variables ({{user_name}}, {count}, <strong>) are excluded from the text that's sent for translation and re-injected into the output file from the preserved source structure. The file that goes in and the file that comes out are structurally identical — the only difference is the language of the human-readable values.

How does Flixu compare to Lokalise + DeepL or Crowdin?

+

Lokalise and Crowdin integrate with DeepL or other MT providers as separate services. The GitHub integration creates pull requests for translated content, which compete with feature branches for the same localization files — causing the merge conflicts that slow sprints. Flixu's GitHub App commits to a dedicated localization branch that's structurally separate from feature branches. Brand Voice and Glossary apply to every translation request as pre-generation constraints, not as post-generation corrections.

Can the Glossary enforce UI terminology across 22+ languages simultaneously?

+

Yes. Glossary terms are specified as payload constraints before translation begins. Every translation request for a project loads the active glossary — regardless of target language. Adding a new approved term applies to all subsequent translations for that project in all configured target languages. Updating an existing term applies immediately to all future translations.

How does the QA workflow work for a PM who doesn't speak the target language?

+

The LQA score provides a quantified signal per segment across five dimensions. A Terminology Consistency flag tells the PM that a glossary term is missing or incorrect — without requiring them to read the target language. The review queue shows only the segments below threshold with the failing dimension marked. Everything above threshold is already auto-approved and deployable. The PM reviews the edge cases; the rest is already done.

Is there a free tier for evaluating the API integration?

+

Yes. The free tier includes API access and translation credits — enough to connect the GitHub App or call the API and validate the output against your actual codebase before committing to a paid plan. The Glossary, Brand Voice, and Translation Memory are included in the free tier; it's the full pipeline, not a stripped-down preview.

Connect your repository and ship localized features on the same release cycle as English.

Install the GitHub App, configure your file paths, and push a commit. The first automated translation runs without a dashboard step.

Related Features