Software30. März 2026Aktualisiert am 23. Oktober 20267 Min. LesezeitRedaktion Nano Concepts

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.

Beitragsbild: Technical Debt priorisieren: Zinsen zahlen oder Schulden tilgen?

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:

AbsichtLeichtfertigUmsichtig
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
UnbewusstFehlendes 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 / AufwandVorgehenBeispiel
Hoch / geringsofort angehen – größter Nutzen pro investierter StundeAbhängigkeit mit Sicherheitslücke aktualisieren, Tests für ein kritisches Modul schreiben
Hoch / hochals eigenes Vorhaben planen, budgetieren und in Etappen umsetzenFramework-Sprung über mehrere Versionen, Umbau eines zentralen Moduls
Gering / geringnebenbei erledigen – nach der Pfadfinderregel: Code etwas besser hinterlassen, als man ihn vorgefunden hatuneinheitliche Benennungen, toter Code
Gering / hochbewusst akzeptieren und dokumentierenSchö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:

  1. Zuerst Tests rund um den betroffenen Bereich schreiben.
  2. Dann in kleinen Schritten umbauen, die jeweils einzeln ausgeliefert werden können.
  3. Neue Implementierungen hinter Feature-Flags aktivieren und bei Problemen sofort zurückschalten.
  4. 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

Begriffe aus diesem Beitrag kurz erklärt

Sebastian MandlmeirRedaktion Nano ConceptsFachbeiträge aus der Praxis – verantwortet von Sebastian Mandlmeir, Geschäftsführer

Weitere Beiträge

In 60 Sekunden zum passenden Angebot

Bedarfsanalyse: Technical Debt priorisieren

Beantworten Sie ein paar kurze Fragen – wir melden uns in der Regel innerhalb von 24 Stunden mit einer ersten Einschätzung.

Projekt anfragen