Technical Debt priorisieren: Zinsen zahlen oder Schulden tilgen?
Technische Schulden sind kein Synonym für schlechten Code – gefährlich werden sie, wenn sie unsichtbar bleiben. So bewerten Sie Altlasten nach Auswirkung und Aufwand und bauen sie planbar ab.

Technical Debt, auf Deutsch technische Schulden, sind Abkürzungen und Altlasten in einer Software, die künftige Änderungen verteuern – wie ein Kredit, für den Sie laufend Zinsen zahlen. Sie priorisieren sie, indem Sie jeden Eintrag nach Auswirkung und Aufwand bewerten, Sicherheitsrisiken zuerst behandeln und für den Abbau einen festen Anteil Ihrer Entwicklungskapazität reservieren.
Jedes Softwareprojekt sammelt mit der Zeit Altlasten an: eine schnelle Lösung kurz vor dem Launch, ein verschobenes Update, ein Modul, das nur noch eine Person versteht. Problematisch wird es, wenn niemand weiß, wie hoch die Schulden sind. Dieser Beitrag zeigt, wie Sie sie sichtbar machen, bewerten und im Plan verankern – statt einer schleichenden Verlangsamung zuzusehen.
Was Technical Debt ist – und was nicht
Die Schulden-Metapher stammt vom Softwareentwickler Ward Cunningham, der sie Anfang der 1990er-Jahre prägte: Wer eine Abkürzung nimmt, nimmt einen Kredit auf. Das ist legitim, solange man die Rückzahlung einplant – denn jede neue Funktion dauert etwas länger, jeder Fehler ist etwas schwerer zu finden. Technische Schuld ist deshalb kein Synonym für schlechten Code. Ein Startup, das eine Idee testen will, darf pragmatische Lösungen wählen. Entscheidend ist, dass alle Beteiligten wissen, wo diese Abkürzungen liegen.
Vier Arten von Schulden
Hilfreich ist die Einteilung von Martin Fowler, die Schulden nach Absicht und Sorgfalt sortiert:
| Absicht | Leichtfertig | Umsichtig |
|---|---|---|
| Bewusst | „Für Tests haben wir keine Zeit.“ – wird schnell zum Problem | „Wir liefern jetzt und räumen danach auf.“ – vertretbar, wenn dokumentiert und eingeplant |
| Unbewusst | Fehlendes Grundwissen zu Architektur und Qualität – lässt sich durch Reviews und Schulung verringern | „Jetzt wissen wir, wie wir es besser hätten bauen sollen.“ – unvermeidlicher Lerneffekt |
Unsichtbare Schuld ist das eigentliche Risiko
- Fehlende Tests: Änderungen werden zum Glücksspiel, weil niemand sicher weiß, was dabei kaputtgeht.
- Unklare Zuständigkeiten: Für zentrale Module fühlt sich niemand verantwortlich.
- Veraltete Abhängigkeiten: Bibliotheken und Frameworks hinken mehrere Versionen hinterher – inklusive bekannter Sicherheitslücken.
- Fehlende Dokumentation: Wissen steckt in Köpfen statt im Projekt.
- Wissen bei einer Person: Fällt sie aus, steht das Modul still.
Woran Sie technische Schuld im Alltag erkennen
Auch ohne Code-Analyse gibt es deutliche Warnsignale, die Geschäftsführung und Fachabteilungen bemerken:
- Kleine Änderungen dauern unverhältnismäßig lange.
- Behobene Fehler tauchen in neuer Form wieder auf.
- Das Team meidet bestimmte Bereiche („Daran fassen wir lieber nicht an“).
- Updates werden immer wieder verschoben.
- Releases werden seltener und riskanter, weil jede Auslieferung Angst macht.
- Neue Entwickler brauchen lange, bis sie produktiv arbeiten können.
Schritt 1: Technical Debt sichtbar machen
Was nicht aufgeschrieben ist, wird nicht priorisiert. Wir führen technische Schuld deshalb als eigene, gekennzeichnete Einträge im Backlog – gleichberechtigt neben neuen Funktionen. Jeder Eintrag enthält eine kurze Beschreibung, die Ursache, die konkrete Auswirkung und eine grobe Aufwandsschätzung.
Wichtige Architekturentscheidungen halten wir zusätzlich schriftlich fest, damit später nachvollziehbar ist, warum etwas so gebaut wurde. Werkzeuge zur statischen Code-Analyse helfen, Hotspots zu finden – Bereiche, die besonders oft geändert werden und gleichzeitig besonders komplex sind. Ein Scan der Abhängigkeiten zeigt veraltete Bibliotheken und bekannte Schwachstellen.
Schritt 2: Technical Debt bewerten und priorisieren
Nicht jede Schuld muss sofort getilgt werden. Wir klassifizieren nach zwei Dimensionen: der Auswirkung und dem Aufwand für die Behebung. Zur Auswirkung zählen vor allem diese Kriterien:
- Sicherheit: bekannte Schwachstellen, fehlende Updates
- Verfügbarkeit: Ausfallrisiko in Kernprozessen
- Entwicklungsgeschwindigkeit: wie oft der Bereich geändert wird und wie viel Mehraufwand jede Änderung kostet
- Wissensrisiko: Nur eine Person kennt das Modul
- Vorgaben: Datenschutz, vertragliche Anforderungen oder das Support-Ende einer Plattform
Das 2×2-Raster
| Auswirkung / Aufwand | Vorgehen | Beispiel |
|---|---|---|
| Hoch / gering | sofort angehen – größter Nutzen pro investierter Stunde | Abhängigkeit mit Sicherheitslücke aktualisieren, Tests für ein kritisches Modul schreiben |
| Hoch / hoch | als eigenes Vorhaben planen, budgetieren und in Etappen umsetzen | Framework-Sprung über mehrere Versionen, Umbau eines zentralen Moduls |
| Gering / gering | nebenbei erledigen – nach der Pfadfinderregel: Code etwas besser hinterlassen, als man ihn vorgefunden hat | uneinheitliche Benennungen, toter Code |
| Gering / hoch | bewusst akzeptieren und dokumentieren | Schönheitsreparaturen in selten genutzten Altbereichen |
Eine Ausnahme gilt für Sicherheit: Veraltete Abhängigkeiten mit bekannten Schwachstellen haben Vorrang, unabhängig vom Aufwand.
Um die Auswirkung greifbar zu machen, hilft eine einfache Überschlagsrechnung: Zinsen pro Monat ≈ Zahl der Änderungen im Bereich × Mehraufwand je Änderung. Angenommen, an einem Modul fallen pro Monat acht Änderungen an, und jede dauert wegen fehlender Tests einen halben Tag länger – dann kostet die Schuld vier Entwicklertage im Monat.
Schritt 3: Abbau in der Roadmap verankern
Technische Schuld konkurriert immer mit neuen Funktionen um Kapazität. Damit sie nicht dauerhaft verliert, braucht sie einen festen Platz: einen vorab vereinbarten Anteil der Kapazität in jeder Planung. Als Faustwert reservieren reife Teams oft grob ein Zehntel bis ein Fünftel; das ist keine Norm, und bei stark belasteter Software darf es vorübergehend mehr sein. Wichtiger als die genaue Zahl ist, dass der Anteil verbindlich ist und bei Termindruck nicht als Erstes gestrichen wird.
Das 2×2-Raster hilft, solche Quartalsbudgets gegenüber der Geschäftsführung zu begründen. Argumentieren Sie dabei in der Sprache des Unternehmens: nicht „Modul X ist unschön“, sondern „Änderungen am Bestellprozess dauern deutlich länger als nötig“ oder „Ohne Update fehlen uns Sicherheits-Patches“. So wird aus einem Technikthema eine nachvollziehbare Geschäftsentscheidung. Zusätzlich lässt sich der Abbau an ohnehin geplante Funktionen koppeln: Wer das Rechnungsmodul ohnehin anfasst, sichert es vorher mit Tests ab und räumt dabei auf.
Beispiel: das gewachsene Kundenportal
Ein Kundenportal ist über Jahre gewachsen. Das verwendete Framework ist mehrere Versionen alt, automatisierte Tests gibt es kaum, und Änderungen am Rechnungsmodul traut sich nur noch ein Entwickler zu. Neue Funktionen dauern spürbar länger als früher.
Im 2×2-Raster landet das Framework-Update wegen bekannter Sicherheitslücken ganz oben. Parallel entstehen Tests für das Rechnungsmodul – mit überschaubarem Aufwand und hoher Wirkung, weil sie jede weitere Änderung absichern. Der Umbau des Moduls selbst wird als eigenes Vorhaben in Etappen geplant. Kosmetische Themen wie uneinheitliche Benennungen werden nebenbei erledigt. So sinken die Zinsen spürbar, ohne dass die Weiterentwicklung monatelang stillsteht.
Refactoring statt Neubau: kleine, sichere Schritte
Der verlockendste Fehler ist der große Neubau. Komplette Rewrites dauern häufig länger als geplant, und in der Zwischenzeit steht die Weiterentwicklung still oder läuft doppelt – im alten und im neuen System. Wir setzen stattdessen auf kleine, sichere Schritte:
- Zuerst Tests rund um den betroffenen Bereich schreiben.
- Dann in kleinen Schritten umbauen, die jeweils einzeln ausgeliefert werden können.
- Neue Implementierungen hinter Feature-Flags aktivieren und bei Problemen sofort zurückschalten.
- Alte Teile erst entfernen, wenn die neuen stabil laufen.
Dasselbe Prinzip gilt für größere Ablösungen: Beim sogenannten Strangler-Fig-Muster ersetzt man einzelne Funktionen schrittweise durch neue Teile, bis das Altsystem nichts mehr zu tun hat. Ein Neubau ist nur gerechtfertigt, wenn die Technologie nicht mehr unterstützt wird, kaum noch Fachkräfte dafür zu finden sind oder die Architektur zentrale Anforderungen grundsätzlich verhindert – und selbst dann gelingt die Ablösung meist besser in Etappen. Ob ein Aufteilen in einzelne Dienste sinnvoll ist, beleuchtet der Beitrag Microservices oder Monolith.
Neue Schulden vorbeugen und Checkliste
Ganz vermeiden lässt sich technische Schuld nicht – aber sie lässt sich steuern. Eine verbindliche Definition of Done mit Tests und Dokumentation, regelmäßige Code-Reviews, eine automatisierte Testpipeline und automatische Abhängigkeits-Updates, zum Beispiel über Dependabot oder Renovate, verhindern, dass Schuld unbemerkt wächst. Wie das im agilen Alltag aussieht, zeigt der Beitrag zu Scrum in Softwareprojekten. Auch laufende Pflege gehört dazu: Wer Updates regelmäßig einspielt, vermeidet große Sprünge – wie ein Wartungsvertrag das regelt.
Checkliste: Technical Debt im Griff
- Schulden als eigene Backlog-Einträge mit Auswirkung und Aufwand erfasst
- Bewertung nach Sicherheit, Verfügbarkeit, Entwicklungsgeschwindigkeit und Wissensrisiko
- Priorisierung im 2×2-Raster, Sicherheitsthemen zuerst
- Fester Kapazitätsanteil für den Abbau in jeder Planung
- Refactoring nur mit Tests und in kleinen Schritten
- Definition of Done, Code-Reviews und Abhängigkeits-Updates als Schutz vor neuer Schuld
So unterstützt Nano Concepts
Sie vermuten, dass Ihre Anwendung langsamer vorankommt, als sie sollte? Im Rahmen unserer Tech-Beratung bewerten wir den Zustand Ihrer Codebasis und erarbeiten einen realistischen Abbauplan – auf Wunsch mit anschließender Wartung und Weiterentwicklung. Im kostenlosen Erstgespräch schildern Sie uns die Lage, danach erhalten Sie ein transparentes Angebot.
Häufige Fragen
Nein. Bewusste Abkürzungen, um schneller am Markt zu sein, sind legitim, wenn sie dokumentiert und nachverfolgt werden. Problematisch ist unsichtbare Schuld wie fehlende Tests, unklare Zuständigkeiten oder veraltete Abhängigkeiten, von der niemand weiß, wie teuer sie wird.
Starten Sie mit den Warnsignalen im Alltag: lange Änderungszeiten, wiederkehrende Fehler, aufgeschobene Updates. Ergänzend helfen ein Scan der Abhängigkeiten, statische Code-Analyse für Hotspots und Gespräche mit dem Team. Das Ergebnis halten Sie als Einträge mit Auswirkung und Aufwand im Backlog fest.
Als Faustwert reservieren reife Teams oft grob ein Zehntel bis ein Fünftel der Kapazität für Refactoring und den Abbau technischer Schuld. Das ist keine Norm: Bei stark belasteter Software darf der Anteil vorübergehend höher liegen. Wichtiger als die Zahl ist, dass der Anteil fest in jeder Planung verankert ist.
Selten. Komplette Neubauten dauern häufig länger als geplant und blockieren die Weiterentwicklung. Meist ist es sinnvoller, den Bestand mit Tests abzusichern und in kleinen Schritten umzubauen – etwa mithilfe von Feature-Flags. Ein Neubau lohnt sich nur, wenn Technologie oder Architektur zentrale Anforderungen grundsätzlich verhindern.
Übersetzen Sie die Technik in Geschäftswirkung: Wie viele Tage kostet ein Änderungswunsch mehr als nötig, welches Ausfall- oder Sicherheitsrisiko besteht, welches Wissen hängt an einer Person? Mit dieser Sprache wird aus „Modul X ist unschön“ eine nachvollziehbare Investitionsentscheidung mit klarem Nutzen.
Passende Leistungen

Wartung & Support
Updates, Monitoring, Backups und Weiterentwicklung – damit Websites, Apps und Software zuverlässig laufen.
Mehr erfahren
Tech-Beratung
Software-Auswahl, Architektur, Code-Review und Digitalisierungsfahrplan – unabhängig und umsetzungsnah.
Mehr erfahren
Softwareentwicklung
Software von der Anforderung bis zum Betrieb – Web, Mobile und Schnittstellen aus einer Hand.
Mehr erfahrenBegriffe aus diesem Beitrag kurz erklärt
Weitere Beiträge

Individualsoftware oder Standardsoftware? Der ehrliche Vergleich
Standardtools sind schnell eingeführt, Individualsoftware passt genau. Welche Lösung sich über drei bis fünf Jahre rechnet – und warum oft eine Kombination am besten ist.
Weiterlesen
Excel ablösen: Wann sich eine eigene Web-App lohnt
Versionschaos, gesperrte Dateien, gebrochene Formeln: Wann Excel an Grenzen stößt, welche Alternativen es gibt und wie der Umstieg auf eine Web-App mit Datenbank im laufenden Betrieb gelingt.
Weiterlesen
REST-API mit OpenAPI: Design, Versionierung und Fehlerformat
Eine gute API ist verständlich, stabil und gut dokumentiert. So entwerfen Sie REST-APIs mit OpenAPI sauber, versionieren ohne Bruch und sparen mit klarer Fehlerkultur Integrationsaufwand.
Weiterlesen