Cheapskate AI Translator: Because Translation Should Not Require a Second Mortgage
There is a particular kind of software project that begins with a detailed architecture document, a product roadmap, and a carefully assembled budget.
This is not that kind of project.
This project began with a simpler question:
Can I create language versions in Optimizely CMS without paying more for an LLM than I absolutely have to?
The answer is now an open source add-on: Cheapskate.AITranslator.
You can find the source code on GitHub and install the published package from the Optimizely NuGet feed.
The honest motivation
I am a cheapskate.
Not in the charming, coupon-clipping sense. In the practical engineering sense. If a free tier, a generous quota, or a small amount of careful request batching can do the job, I would prefer that to adding another monthly AI bill to the household budget.
The goal is not to avoid paying for good services forever. The goal is to pay as little as I can get away with while still delivering useful translations and a maintainable CMS workflow.
That means the add-on is designed around choice:
- Google Gemini-compatible chat completions
- GroqCloud-compatible chat completions
- Microsoft Azure Translator
- DeepL API Free
- Custom OpenAI-compatible providers
Some providers offer free tiers, some offer free quotas, and some are inexpensive enough to be useful when a free option is not appropriate. The add-on does not assume that one provider, one pricing model, or one API will remain the best choice forever.
What the add-on does
Optimizely content editors can create draft language versions from the editor and choose whether to translate them with AI after the drafts are created.
The add-on can:
- Create all missing language branches or one selected target language
- Keep the new versions as drafts rather than publishing them
- Optionally follow linked content in ContentArea properties
- Translate language-specific text and Rich Text content
- Preserve HTML structure while translating visible text
- Run translation in the background after draft creation
- Use different providers through one CMS settings screen
The workflow is intentionally modest. It creates drafts, starts translation work, and reports the job status. It does not pretend that an automated translation should bypass editorial review.
That last part is important. A translation engine can be very good and still occasionally produce something that makes a human editor stare at the screen for a while. Drafts are a useful place for that staring to happen.
The small trick that saves API calls
The add-on can combine multiple translatable properties into one JSON request instead of making one API request per property.
Without batching, a page with a title, teaser, body, call to action, and several blocks can turn into a small parade of API calls. That is inefficient, costs more, and can hit provider rate limits faster than necessary.
With batching enabled, the worker groups translation entries into bounded requests according to configured input and output token limits. The provider receives a structured payload, translates the values, and returns the translated entries for the background worker to write back to the draft.
In plain English:
Fewer trips to the API means fewer opportunities for the API to say, "Please slow down."
Batching does not remove provider limits, and it does not make an unlimited service out of a limited one. It simply uses the available quota more sensibly. The request-size limits remain configurable because different providers have different capabilities and pricing rules.
Why support several providers?
Because depending on one provider is an excellent way to discover that provider's outage page at the worst possible moment.
More seriously, different projects have different constraints:
- A project may already have an Azure subscription and prefer Azure Translator.
- A developer may want to use a free Gemini or GroqCloud quota.
- A team may prefer DeepL for a particular language pair.
- An organization may have its own OpenAI-compatible gateway.
- A provider's model, pricing, quota, or terms may change.
The add-on keeps the CMS workflow stable while allowing the translation backend to change. Provider credentials and options live in CMS settings rather than in source control, and the custom provider option gives developers room to connect a compatible internal service.
This is not Optimizely Language Manager
A very important clarification: Cheapskate.AITranslator is not intended to replace Optimizely's official Language Manager add-on.
Language Manager is the official product for teams that need its supported translation-management workflow, integrations, governance, and product support. This add-on has a narrower and more developer-oriented purpose.
Cheapskate.AITranslator brings the implementation into the developer's control. The source code is available, the behavior can be inspected, and the add-on can be customized for a particular Optimizely CMS solution.
That may mean changing:
- Which content properties are translated
- How linked content is traversed
- How prompts are written
- Which provider is called
- How batches are sized
- How translation jobs are queued or reported
- Which editorial safeguards are required
If your project needs an officially supported translation-management product, use Language Manager. If your project needs a small, inspectable starting point that your team can adapt, this add-on may be useful.
It is not a product-versus-product argument. It is a choice between a supported official solution and a source-controlled developer tool with a smaller scope.
Open source is the point
The most valuable part of this add-on is not the skate icon or the settings page. It is the ability to see what happens between clicking Create Language Versions and saving a translated draft.
Developers can review the code, change the translation rules, add provider behavior, adjust batching, and fit the workflow to their own content model. The add-on is deliberately not a sealed box that asks everyone to accept the same assumptions.
That also means responsibility comes with the freedom:
- Review generated translations before publishing.
- Protect provider credentials.
- Check provider terms and quotas.
- Test prompts and content types in a non-production environment.
- Keep the add-on aligned with the CMS version used by the project.
Cheap is good. Cheap and mysterious is less good.
Getting started
The project targets Optimizely CMS 13 and .NET 10 on the main branch. The legacy CMS 12 implementation remains on the CMS-12-base branch.
Install the CMS 13 package with:
dotnet add .\YourCmsProject.csproj package Cheapskate.AITranslator --version 2.0.0
Then configure a provider under Settings > AI Translator, open localizable content in the editor, and use the Create Language Versions command.
The resulting versions are drafts. The AI translation runs in the background when enabled, and the editor remains responsible for the final content review.
Final accounting
The philosophy is simple:
- Use the provider that fits the project.
- Use free quotas where they are enough.
- Batch requests so the quota lasts longer.
- Keep the workflow in developer-controlled source code.
- Spend money when spending money is actually justified.
That is the entire cheapskate strategy. It is not glamorous, but neither is discovering a surprisingly large AI invoice after a bulk translation job.
Cheapskate.AITranslator is open source under the MIT license: a small Optimizely add-on for teams that want draft language creation, optional AI translation, multiple provider choices, and a little more control over where the money goes.
Comments