Wie der Product Owner das Auftürmen technischer Schulden verhindert

Bei einer agilen Softwareentwicklung muss die Implementierung laufend an die Anforderungen angepasst werden. Wird zu einem Zeitpunkt deutlich, dass eine Überarbeitung nötig ist, so spricht man von einer technischen Schuld. Meistens sind sie für den Endbenutzer nicht sichtbar, können jedoch die Entwicklungsleistung beeinträchtigen. Technische Schulden führen zu exponentiellem Mehraufwand in der Wartung, schlechter Erweiterbarkeit und schwacher Systemleistung.

Auf den ersten Blick scheint nur das Entwicklungsteam dafür verantwortlich, technische Schulden zu verwalten und zu beheben. Doch auch der Product Owner (PO) muss den Überblick über diese behalten, da er für das Budget und die anfallenden Wartungskosten verantwortlich ist. Dadurch kann er zukünftige Anpassungen am System besser abschätzen und beim Beheben der technischen Schulden Einfluss auf die Priorisierung nehmen.

Auswirkungen von technischen Schulden

Abbildung 1 zeigt den Anstieg von technischen Schulden und wie Refactorings (Überarbeiten der Software) sie wieder abbauen.

Abbildung 1: Entwicklung von technischen Schulden

Eine technische Schuld wirkt sich kurzfristig möglicherweise nur marginal auf das Produkt aus. Längerfristig steigt der Aufwand zur Behebung jedoch exponentiell (rote Pfeile). Folgefehler werden immer schwerer nachvollziehbar, bis zu dem Punkt, an dem jede Anpassung zu einer schmerzhaften Anstrengung wird. Oder in den Worten von Benjamin Franklin:

Der bittere Nachgeschmack einer schlechten Qualität bleibt lange nach der Süsse eines niedrigen Preises zurück.

Technische Schulden so früh wie möglich anzugehen, ist deshalb essenziell.

Der PO ist dafür verantwortlich, den grössten Mehrwert aus der gegebenen Entwicklungsleistung zu erhalten. Damit das Entwicklungsteam nicht blockiert wird, müssen technische Schulden laufend ausgebessert werden. Regelmässig muss das System wieder in den Korridor geringer technischer Schulden zurückgebracht werden. Es entsteht eine stetige Folge von Erweiterung und Refactoring.

Ursachen von technischen Schulden

Die Ursachen von technischen Schulden sind vielfältig. Manchmal werden sie bewusst in Kauf genommen. Andere schleichen sich unbewusst ein und sind erst zu einem späteren Zeitpunkt erkennbar. Drei häufige Ursachen weshalb technische Schulden entstehen, sind im Folgenden etwas genauer beleuchtet:

Die Anforderungen ändern sich
Oft ändern sich Anforderungen an das Produkt im Verlauf eines Projekts. Durch die Änderung passt die ursprünglich gewählte Softwarearchitektur möglicherweise nicht mehr ideal zur Anforderung.

Zeitdruck
Um ein Feature termingerecht abzuschliessen wählt das Projektteam eine suboptimale Lösung. Dies kann kurzfristig Sinn machen, allerdings nur wenn zeitnah ein Refactoring eingeplant wird.

Mangel an Informationen
Dem Entwickler fehlen entscheidende Informationen, um das Problem ganzheitlich zu erfassen und eine nachhaltige Lösung zu entwickeln.

Umgang mit technischen Schulden

Vorbeugen
Bereits präventiv kann das Projektteam Vorkehrungen treffen, damit sich technische Schulden nicht ansammeln. Der PO kann Rahmenbedingungen schaffen, um technische Schulden zu vermeiden. Hilfreich sind dabei gute Priorisierung, klar definierte Anforderungen, umfassendes Testen (Komponenten-, Integrations-, System-, Leistungs- und Abnahmetests halten die Qualität hoch und können technische Schulden früh aufdecken) sowie zeitnahe und regelmässige Refactorings.

Akzeptieren
Die Softwareentwicklung ist ein stetiger Lernprozess. Zu den daraus gewonnenen Erkenntnissen gehören die technischen Schulden. Der PO sollte sich bewusst sein, dass technische Schulden existieren und sie die Qualität negativ beeinflussen. Die Weiterentwicklung wird durch sie verlangsamt, verteuert und schlimmstenfalls verunmöglicht.

Identifizieren
Ein Entwicklungsteam kann in der Regel aus dem Stand eine Liste von bestehenden Schulden aufzählen. Automatisierte und manuelle Reviews können auch weitere technische Schulden aufdecken. Das Entwicklungsteam ist dafür zuständig, technische Schulden zu identifizieren und für den PO transparent aufzuzeigen.

Abschätzen & Priorisieren
Gemeinsam schätzt der PO mit dem Entwicklungsteam den Aufwand zur Behebung ab. Aufgrund von Aufwand und Ertrag kann nun die technische Schuld priorisiert und deren Behebung eingeplant werden. Hier muss der PO die Balance halten, damit das Produkt funktional wachsen kann und gleichzeitig die gute Qualität erhalten bleibt.

Beheben
Kritische technische Schulden müssen laufend behoben werden. Zusätzlich sollte für jede Iteration Budget für Refactorings eingeplant werden. Damit bleibt das Projekt im Korridor geringer technischer Schulden und ermöglicht ein langlebiges und hochwertiges System.

Fazit

Technische Schulden sind ein Nebenprodukt der agilen Softwareentwicklung. Werden Refactorings vernachlässigt, so können sich technische Schulden kumulieren. Der Product Owner und das Entwicklungsteam sorgen gemeinsam dafür technische Schulden tief zu halten. Der PO priorisiert dafür jene technischen Schulden, die das Projekt am stärksten beeinträchtigen. Dadurch kann der exponentielle Anstieg des Aufwands zur Behebung von technischen Schulden durchbrochen werden. Das Entwicklungstempo bleibt hoch und die Zeit kann für projektrelevante Funktionen eingesetzt werden.