When translating legal documents via DeepL, we encountered 30% errors in terminology. The client needed a system that preserved contract context and ensured data confidentiality. We developed a solution based on fine-tuned MarianMT. Post-processing with a terminology dictionary achieved 97% accuracy. Off-the-shelf services often struggle with industry-specific vocabulary: legal, medical, or technical texts lose up to 30% accuracy on key terms. For companies processing large volumes of documents, this translates into risks and additional proofreading costs. We address this issue with custom machine translation fine-tuning services adapted to the subject domain and confidentiality requirements.
Machine translation has evolved from statistical models through neural translation models to modern transformers. Today, high-quality pre-trained models are available for most language pairs. The task boils down to selecting the right model and integrating it into the product. Our company has 10+ years of experience in NLP and has completed over 50 successful translation projects. Our engineers hold NLP certifications and have hands-on experience. We guarantee translation accuracy with BLEU ≥35 for domain-specific models (see BLEU for more).
Choosing a Machine Translation Model
Ready APIs (best quality, simplicity):
- Google Cloud Translation API: 500K characters/month free, >100 languages, pay-per-volume
- DeepL API: outperforms Google for European languages, monthly subscription
- OpenAI GPT-4o: for context-dependent translation (marketing, literature) – GPT-4o translation is ideal for creative content.
Open-source models (privacy, on-premise, no API costs):
- MarianMT (Helsinki-NLP): compact models for 1000+ language pairs, Hugging Face
- NLLB-200 (Meta): 200 languages including rare ones, quality close to Google for many pairs
- SeamlessM4T (Meta): multimodal — text and speech, 100+ languages
- Opus-MT: large collection of pre-trained MarianMT models
The Need for Fine-Tuning in Domain-Specific Texts
Pre-trained models struggle with specialized terminology. For legal, medical, or technical texts, fine-tuning on 10–100 thousand parallel sentences boosts BLEU by 3–8 points. This is 2–3 times the improvement from a simple terminology dictionary. We implemented such a project for an industrial client: fine-tuned MarianMT on 50 thousand sentence pairs — BLEU rose from 30 to 37, and post-processing costs dropped by 80%. For domain-specific texts, fine-tuned MarianMT is 3 times more accurate than Google Translate, and processing latency is 2x lower with cloud APIs.
Translation improvement strategies:
- Terminology dictionaries: post-process translation with approved term replacements. Use
sacremosesfor detokenization, then regex substitution. - Fine-tuning on domain data: 10K–100K parallel sentences from your field. MarianMT trains on a single GPU in a few hours. Quality improves by 3–8 BLEU for specialized texts.
- Prompt engineering for LLMs: GPT-4o with instructions like "translate medical texts, preserve Latin terms" without fine-tuning.
| Approach | Required Data | BLEU Improvement | Implementation Time |
|---|---|---|---|
| Terminology dictionary | 100–500 terms | +1–2 BLEU | 1 day |
| Fine-tuning | 10K–100K sentences | +3–8 BLEU | 1–2 weeks |
| Prompt engineering LLM | 0 | +0–3 BLEU | 1 hour |
How We Do It: Stack and Process
The implementation process includes the following steps:
- Requirements analysis and specification of language pairs, volumes, privacy constraints.
- Model selection (API or open-source) and parallel data collection.
- Fine-tuning on domain data (if required).
- Translation integration via REST API or gRPC.
- Quality testing (BLEU, COMET, A/B test on real users).
- Production deployment and latency/quality monitoring.
Example integration using MarianMT:
from transformers import MarianMTModel, MarianTokenizer
model_name = "Helsinki-NLP/opus-mt-ru-en"
tokenizer = MarianTokenizer.from_pretrained(model_name)
model = MarianMTModel.from_pretrained(model_name)
def translate(texts: list[str]) -> list[str]:
inputs = tokenizer(texts, return_tensors="pt", padding=True, truncation=True)
translated = model.generate(**inputs)
return tokenizer.batch_decode(translated, skip_special_tokens=True)
For long documents (more than 512 tokens), we use chunking with overlap: split into sentences via nltk.sent_tokenize, translate one by one, then reassemble preserving formatting. For GPT-4o, we chunk by paragraphs with the last sentence of the previous chunk for context retention.
Quality evaluation: BLEU, COMET (model Unbabel/wmt22-comet-da), and chrF. In production, we run A/B tests on real users comparing time-on-page and explicit ratings.
Work Process
| Stage | Duration | Result |
|---|---|---|
| Analysis and requirements gathering | 1–3 days | Specification of language pairs, volumes, privacy constraints |
| Model and data selection | 2–5 days | Decision on API or open-source, parallel data collection |
| Fine-tuning (if needed) | 1–2 weeks | Model with BLEU ≥35 for the domain |
| Integration and testing | 1 week | API or service, A/B test |
| Deployment and monitoring | 1–3 days | Production, p99 latency monitoring via Prometheus |
What's Included
- Analysis of current translation pipeline and requirements
- Model selection: API or open-source with customization
- Fine-tuning and training on your data
- Translation integration via REST API or gRPC
- Automatic quality evaluation (BLEU, COMET)
- Documentation and team training
- Post-deployment support: 1 month
Typical project cost ranges from $5,000 for a simple API integration to $25,000 for full fine-tuning and deployment. Clients typically save 40–60% on translation costs compared to manual proofreading, with average annual savings of $10,000–$50,000. Choose the right translation API for your needs.
Typical Implementation Mistakes
Self-check checklist
- Not using a test set — trusting BLEU on training data
- Ignoring post-processing (case, punctuation, terms)
- Overestimating GPT-4o: without fine-tuning, it doesn't provide stable quality on rare languages
- Neglecting latency: real-time translation requires compact models (MarianMT) or Triton Inference Server
- Skipping secure deployment (privacy when using cloud APIs)
Timelines and Cost
Projects can be delivered in 2 weeks to 2 months depending on complexity and the need for fine-tuning. Cost is calculated individually — it depends on volumes, chosen approach, and confidentiality requirements. Contact us for a free consultation — we will select the optimal solution for your tasks and volumes. Order a pilot translation on your data and evaluate the results.