Django-Lokalisierung für Solo-Entwickler: Von Wochen zu Minuten

Du hast eine Django-App gebaut. Sie funktioniert, Nutzer registrieren sich, und jetzt willst du Menschen erreichen, die kein Englisch sprechen. Das Problem ist offensichtlich, sobald man es sich anschaut: Djangos Internationalisierungs-Framework ist hervorragend im Extrahieren übersetzbarer Strings, aber es tut absolut nichts, um die Übersetzungen einzufügen. Diesen Teil musst du selbst erledigen.

Wenn du ein Solo-Entwickler oder ein Zwei-Personen-Team bist, kann die Lücke zwischen makemessages und einer vollständig übersetzten App riesig erscheinen. Ich gehe die realistischen Optionen durch, erkläre, warum die meisten davon für kleine Teams nicht funktionieren, und zeige einen Workflow, der die Übersetzung von einer mehrwöchigen Aufgabe zu einem Zwei-Minuten-Befehl macht.

Die traditionellen Optionen (und warum sie wehtun)

Option 1: Copy-Paste aus Google Translate

Der häufigste erste Versuch. Du öffnest deine .po-Datei, kopierst jede msgid in Google Translate, fügst das Ergebnis als msgstr ein und wiederholst. Für jeden String. In jeder Sprache.

Eine typische Django-App hat 200-500 übersetzbare Strings. Wenn du in fünf Sprachen übersetzt, sind das 1.000-2.500 Copy-Paste-Zyklen. Selbst wenn jeder nur 30 Sekunden dauert, sind das 8-20 Stunden geistlose Arbeit. Und das ist bevor du die Formatierungsfehler, kaputten Platzhalter und die unweigerlich auftretende inkonsistente Terminologie korrigierst.

Schlimmer noch: Du musst es im nächsten Sprint wieder machen, wenn du neue Strings hinzufügst.

Option 2: Professionelle Übersetzer

Professionelle Übersetzung kostet typischerweise $0,10 bis $0,25 pro Wort. Eine Django-App mit 500 Strings mit durchschnittlich 8 Wörtern ergibt ungefähr 4.000 Wörter. Bei $0,15/Wort sind das $600 pro Sprache, oder $3.000 für fünf Sprachen.

Für ein VC-finanziertes Startup ist das ein Rundungsfehler. Für einen Solo-Entwickler, der $9/Monat pro Nutzer verlangt, kann das den gesamten Quartalsumsatz auffressen.

Option 3: Fiverr und Freelance-Marktplätze

Auf Fiverr kann man Übersetzer für $20-50 pro Sprache finden. Einige sind wirklich qualifiziert. Viele fügen deinen Text einfach in Google Translate ein und berechnen dir dafür Geld. Am Ende hast du die gleiche Qualität wie bei Option 1, plus eine zusätzliche Kommunikationsrunde und eine Woche Wartezeit.

Option 4: Crowdin, Transifex oder Weblate

Diese Plattformen sind leistungsstark, aber sie sind für Projekte mit dedizierten Übersetzungsteams konzipiert. Der Setup-Overhead (Repositories synchronisieren, Translation Memory konfigurieren, Zugriffsrechte für Mitwirkende verwalten) ist übertrieben, wenn du die einzige Person im Projekt bist. Monatliche Abonnements beginnen bei $30-150/Monat für bezahlte Stufen, und selbst kostenlose Stufen erfordern, dass du eine weitere Drittanbieter-Integration pflegst.

Option 5: Alles in ChatGPT einfügen

Das funktioniert in puncto Qualität tatsächlich überraschend gut. Du fügst den Inhalt deiner .po-Datei in ChatGPT oder Claude ein, bittest um Übersetzungen und bekommst brauchbare Ergebnisse. Das Problem ist, dass es nicht skaliert. Du musst die nicht übersetzten Strings manuell extrahieren, den Prompt formatieren, die Antwort zurück ins .po-Format parsen und das Batching handhaben, wenn du die Kontextlimits überschreitest. Es funktioniert einmal. Als wiederholbarer Workflow bricht es zusammen.

Der Automatisierungsansatz

Was wäre, wenn der gesamte Übersetzungsschritt ein einziger Befehl wäre? Das ist die Idee hinter TranslateBot, einem Open-Source Django Management Command, der deine .po-Dateien liest, nicht übersetzte Strings an einen KI-Anbieter sendet und die Übersetzungen im richtigen Format zurückschreibt.

So richtest du es ein.

Schritt 1: TranslateBot installieren

uv add --dev translatebot-django

Oder mit pip:

pip install translatebot-django

Füge es zu deinen installierten Apps hinzu:

# settings.py
INSTALLED_APPS = [
    # ...
    'translatebot_django',
]

Schritt 2: KI-Anbieter konfigurieren

Füge zwei Einstellungen hinzu:

# settings.py
import os

TRANSLATEBOT_API_KEY = os.getenv("OPENAI_API_KEY")
TRANSLATEBOT_MODEL = "gpt-4o-mini"

TranslateBot funktioniert mit OpenAI, Anthropic Claude, Google Gemini und über 100 weiteren Modellen über LiteLLM. Es unterstützt auch DeepL als dediziertes Übersetzungs-Backend.

Schritt 3: TRANSLATING.md erstellen (optional, aber empfohlen)

Eine TRANSLATING.md-Datei im Projektstamm gibt der KI Kontext über deine Anwendung. Das ist es, was generische maschinelle Übersetzung von Übersetzungen unterscheidet, die tatsächlich zu deinem Produkt passen:

# Translation Context

## About This Project
A personal finance tracker for freelancers. Users track invoices,
expenses, and tax obligations.

## Tone
- Friendly and informal
- Use "du" in German, "tu" in French
- Keep financial terms precise

## Terminology
- "invoice" = "Rechnung" (German), "facture" (French)
- "dashboard" = keep as English loanword in all languages
- "freelancer" = keep as English loanword in German

Diese Datei wird mit jeder Übersetzungsanfrage mitgesendet, sodass die KI konsistent den richtigen Ton und die richtige Terminologie verwendet.

Schritt 4: Übersetzen

python manage.py makemessages -l de -l fr -l nl -l es -l ja
python manage.py translate
python manage.py compilemessages

Drei Befehle. Das war's. TranslateBot findet alle nicht übersetzten Strings in all deinen .po-Dateien, übersetzt sie in Batches und schreibt die Ergebnisse zurück. Standardmäßig werden nur leere Einträge übersetzt, sodass ein erneutes Ausführen des Befehls nach dem Hinzufügen neuer Strings nur die neuen übersetzt.

Wie das in der Praxis aussieht

Hier ist ein realistischer Sprint-Workflow für einen Solo-Entwickler, der fünf Sprachen unterstützt:

Montag: Du baust ein neues Feature. Du fügst ein paar neue übersetzbare Strings mit gettext() und {% trans %} hinzu, während du entwickelst.

from django.utils.translation import gettext_lazy as _

class InvoiceView(View):
    def post(self, request):
        # New string added during development
        messages.success(request, _("Invoice sent successfully."))

Vor dem Commit: Du führst drei Befehle aus:

python manage.py makemessages -a --no-obsolete
python manage.py translate
python manage.py compilemessages

Der translate-Befehl erkennt die neuen nicht übersetzten Einträge und übersetzt nur diese. Wenn du 5 neue Strings hinzugefügt hast und 5 Sprachen unterstützt, erstellt er 25 Übersetzungen in einem einzigen API-Aufruf. Der gesamte Prozess dauert unter einer Minute.

Du commitest deinen Code, Templates und die aktualisierten .po/.mo-Dateien zusammen. Übersetzungen sind Teil deines normalen Entwicklungsablaufs, kein separates Projekt.

Vorschau vor dem Commit

Wenn du die Übersetzungen sehen möchtest, bevor sie auf die Festplatte geschrieben werden, verwende den Dry-Run-Modus:

python manage.py translate --dry-run

Dieser gibt jede Übersetzung im Terminal aus, ohne Dateien zu verändern.

Der Kostenvergleich

Hier wird Automatisierung schwer zu widerlegen.

Eine kleine bis mittlere Django-App mit rund 500 übersetzbaren Strings kostet mit gpt-4o-mini typischerweise weniger als $0,01 pro Sprache. Für die meisten Solo-Projekte deckt das kostenlose DeepL-Kontingent (500.000 Zeichen/Monat) alles ohne Kosten ab.

Um es klar zu sagen: KI-Übersetzungen sind nicht perfekt. Budget-Humanübersetzungen auch nicht. Der Unterschied ist, dass KI-Übersetzungen fast nichts kosten, sofort verfügbar sind und jederzeit neu ausgeführt werden können.

CI-Integration: Nie unübersetzte Strings ausliefern

Eines der nützlichsten Muster, die ich als Solo-Entwickler gefunden habe, ist das Hinzufügen einer Übersetzungsprüfung zum CI. TranslateBot enthält einen check_translations-Befehl, der fehlschlägt, wenn eine .po-Datei nicht übersetzte oder unscharfe Einträge hat:

# .github/workflows/ci.yml
jobs:
  translations:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: astral-sh/setup-uv@v4
        with:
          enable-cache: true
      - run: uv python install
      - run: uv sync --frozen
      - name: Install gettext
        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends gettext
      - name: Check translations
        run: uv run python manage.py check_translations --makemessages

Wenn du ein neues {% trans %}-Tag in einem Template hinzufügst und vergisst, translate auszuführen, fängt CI es ab:

locale/de/LC_MESSAGES/django.po: 1 untranslated, 0 fuzzy
locale/fr/LC_MESSAGES/django.po: 1 untranslated, 0 fuzzy
CommandError: Translation check failed

Das verwandelt Übersetzungen von etwas, an das du denken musst, in etwas, das du nicht vergessen kannst.

Praktische Tipps

Starte mit zwei oder drei Sprachen. Du musst nicht am ersten Tag in 15 Sprachen launchen. Wähle die Sprachen, in denen du die meisten Nutzer oder den größten adressierbaren Markt hast. Deutsch, Französisch und Spanisch decken für europäische Märkte viel ab.

Lass Muttersprachler kritische Strings überprüfen. KI-Übersetzungen sind für die meisten UI-Texte gut genug, aber die Überschrift deiner Landingpage und dein Onboarding-Flow verdienen einen menschlichen Blick. Bitte einen Freund, Nutzer oder jemanden in einem Community-Forum, 10 Minuten mit der Überprüfung der sichtbarsten Strings zu verbringen.

Verwende Dry-Run vor dem Überschreiben. Wenn du jemals alles neu übersetzen musst (zum Beispiel nach der Aktualisierung deiner TRANSLATING.md mit besseren Terminologierichtlinien), sieh dir die Änderungen zuerst an:

python manage.py translate --overwrite --dry-run

Halte TRANSLATING.md in der Versionskontrolle. Es ist Teil der Übersetzungskonfiguration deines Projekts. Wenn du Terminologie- oder Tonrichtlinien aktualisierst, wird der nächste translate-Lauf diese Änderungen für alle neuen Strings widerspiegeln.

Übersetze bei Bedarf pro App. Wenn du nur Strings in einer App geändert hast, kannst du die Übersetzung einschränken:

python manage.py translate --app billing

Von Wochen zu Minuten

Djangos Internationalisierungs-Framework ist eines der besten in jedem Web-Framework. Die Tools für makemessages, Locale-Verzeichnisse und compilemessages sind ausgereift und zuverlässig. Das einzige fehlende Teil war der Übersetzungsschritt selbst. Das war früher der teure, langsame Teil.

Mit TranslateBot wird der Workflow zu:

1. Code mit gettext() und {% trans %} wie gewohnt schreiben
2. makemessages ausführen, um Strings zu extrahieren
3. translate ausführen, um Übersetzungen einzufügen
4. compilemessages ausführen, um zu kompilieren
5. Alles zusammen committen

Für einen Solo-Entwickler bedeutet das, dass Lokalisierung nicht mehr ein Projekt ist, das man für „irgendwann" plant. Es ist etwas, das du heute tun kannst, in der Zeit, die es braucht, eine Tasse Kaffee zu machen.

TranslateBot ist Open Source und verfügbar auf PyPI und GitHub. Installiere es, führe den Befehl aus und sieh deine App in einer neuen Sprache in Minuten.