---
title: Technische Schulden reduzieren und verhindern | MPOWR IT
description: Warum technische Schulden entstehen, wie ihr sie objektiv messt (MMI, Kopplungsmetriken), in drei Phasen abbaut und mit ADRs und Fitness Functions dauerhaft verhindert.
image: https://www.mpowr-it.de/hubfs/Blog/Grafiken/titelbild-technische-schulden.png?v=20261109b
---

[![MPOWR IT Logo Farbig](https://www.mpowr-it.de/hubfs/Downloads/mpowr-logo-links-farbig.svg)](https://www.mpowr-it.de/?hsLang=de)

- [Leistungen](https://www.mpowr-it.de/leistungen) 
    - [IT-Strategieberatung](https://www.mpowr-it.de/leistungen/it-strategieberatung)
    - [System & Softwarearchitektur](https://www.mpowr-it.de/leistungen/system-und-softwarearchitektur)
    - [Tech Due Diligence](https://www.mpowr-it.de/leistungen/tech-due-diligence)
    - [IT & Cloud Security](https://www.mpowr-it.de/leistungen/it-cloud-security)
    - [KI-Readiness-Check](https://www.mpowr-it.de/leistungen/ai-readiness-assessment)
    - [IAM](https://www.mpowr-it.de/leistungen/identity-access-management)
- [Kundenreferenzen](https://www.mpowr-it.de/projekte)
- [Über uns](https://www.mpowr-it.de/ueber-uns)
- Ressourcen 
    - [GitHub](https://github.com/mpowr-it)
- [Kontakt](https://www.mpowr-it.de/kontakt)

[Termin vereinbaren](https://www.mpowr-it.de/termin-vereinbaren?hsLang=de)

[Termin vereinbaren](https://www.mpowr-it.de/termin-vereinbaren?hsLang=de)

Blog

# Technische Schulden reduzieren und verhindern

Technische Schulden entstehen selten absichtlich, aber immer mit Zinsen. Wie ihr sie mit MMI und Kopplungsmetriken objektiv messt, in drei Phasen abbaut und mit ADRs und Fitness Functions dauerhaft verhindert.

![Ein Netzwerkkabel-Stecker steht aufrecht auf seinem gewundenen Kabel und kehrt die Trümmer eines zerschlagenen Felsbrockens mit der Aufschrift Technical Debt zur Seite, daneben liegt ein Hammer](https://www.mpowr-it.de/hs-fs/hubfs/Blog/Grafiken/titelbild-technische-schulden.png?v=20261109b&width=1280&height=720&name=titelbild-technische-schulden.png)

Im [ersten Beitrag](https://www.mpowr-it.de/blog/entwicklungsgeschwindigkeit?hsLang=de) haben wir gezeigt, warum Entwicklungsteams langsamer werden: Technische Schulden sammeln sich an, die Architektur erodiert, und bei jeder Änderung werden Zinsen fällig. Dieser Beitrag beantwortet die Frage, die danach immer kommt: Was tun wir dagegen, und wie verhindern wir, dass es wieder passiert?

Die kurze Antwort: messen statt schätzen, in Phasen abbauen statt alles auf einmal, und Leitplanken einziehen, die im Alltag halten. Die lange Antwort folgt.

## Warum entstehen bei uns ständig neue technische Schulden?

Technische Schulden entstehen, wenn bewusst oder unbewusst suboptimale technische Entscheidungen getroffen werden, die später Mehraufwand erzeugen. So interpretiert Carola Lilienthal in „Langlebige Software-Architekturen“ die Metapher, die Ward Cunningham 1992 geprägt hat. Entscheidend ist das Wort „unbewusst“. Die meisten Schulden nimmt niemand absichtlich auf. Sie entstehen aus vier Ursachen, die wir in unzähligen analysierten Systemen immer wieder gesehen haben:

1. **Programmieren können viele, Architektur gelernt haben wenige.** Ohne gemeinsames Architekturverständnis verwirklicht jeder Entwickler seine lokalen Entwurfsideen in seinem Teil des Systems. Das Ergebnis heißt dann „historisch gewachsen“.
2. **Die Erosion steigt unbemerkt.** Unter Zeitdruck weichen Entwickler von der geplanten Architektur ab, bauen Beziehungen ein, die Schnittstellen oder Schichten missachten, oder kopieren Code, statt zu abstrahieren. Jede einzelne Abweichung ist klein. In Summe verschwindet die Architektur.
3. **Systeme sind größer, als ein Mensch überblicken kann.** Neben der unvermeidlichen Komplexität des Fachproblems kommt zugelassene Komplexität (accidental complexity) hinzu: Mehrfachimplementierungen, nicht benötigte Funktionalität, Technologie, die jemand ausprobieren wollte.
4. **Qualität gilt als bezahlt.** „Es läuft doch, warum sollen wir für Qualität extra zahlen?“ Wer Software als einmalig herstellbares Gut versteht, plant keine Zeit für ihren Erhalt ein.

Neal Ford et al. ergänzen in „Software Architecture: The Hard Parts“ einen Mechanismus, den jedes Team kennt: Wichtige, aber nicht dringende Prinzipien verlieren gegen das Dringende. Ein Beispiel ist der Auto-Import-Dialog der IDE, den Entwickler reflexartig wegklicken. So entstehen zyklische Abhängigkeiten zwischen Komponenten, die niemand wollte. Code-Reviews bemerken das zu spät; nach einer Woche ist der Schaden in der Codebase.

Aus unserer Praxis kommt eine fünfte Quelle dazu, die in beiden Büchern noch keine Rolle spielt: KI-Coding-Agenten erzeugen in hohem Tempo Code, der augenscheinlich funktioniert, aber nicht zur vorhandenen Architektur passt. Ohne explizite Leitplanken verschuldet sich ein Team damit noch schneller als je zuvor.

## Welche Arten von technischen Schulden gibt es?

Lilienthal unterscheidet vier Arten, und die Reihenfolge, in der man sie angeht, ist nicht beliebig:

- **Implementationsschulden:** Code-Smells wie lange Methoden oder Duplikate.
- **Design- und Architekturschulden:** Klassen, Pakete, Schichten und Module sind uneinheitlich geschnitten, teilen kein Muster, sind komplex und passen nicht zur geplanten Architektur.
- **Testschulden:** Es fehlen Tests, oder es wird nur der Best-Case geprüft.
- **Dokumentationsschulden:** Entwurfsentscheidungen sind nirgends festgehalten, der Überblick über die Architektur existiert nur in Köpfen oder einem UML-Diagramm.

Geringe Testschulden sind die Basisanforderung. Ohne automatisierte Tests ist jedes Refactoring ein Risiko, und ein Team, das Refactorings fürchtet, baut keine Schulden ab. Wenn euer Code Angst statt Spaß macht, ist das meistens die erste Baustelle.

## Wie misst man technische Schuld objektiv?

Die Frage nach dem Bauchgefühl ist berechtigt: Entwickler sagen „der Code ist schlecht“, das Management hört „die wollen alles neu schreiben“. Objektive Kennzahlen lösen diesen Konflikt, weil sie beiden Seiten dieselbe Sprache geben.

**Erster Indikator: Systemgröße gegen Teamkapazität.** Wir fragen in jedem Assessment zuerst nach der Größe des Systems und dann nach Größe und Leistungsfähigkeit der Entwicklungsabteilung. Systeme mit guter Architektur binden für Wartung ein bis zwei Vollzeitentwickler pro 500.000 Zeilen Code. Wenn 30 Entwickler an drei Millionen Zeilen nur noch warten und kaum neue Features ausliefern, ist das System mit hoher Wahrscheinlichkeit stark verschuldet.

**Modularity Maturity Index (MMI).** Lilienthal und ihr Team haben seit 2008 ein Bewertungsschema entwickelt, das Systeme vergleichbar macht. Es bewertet drei Prinzipien auf einer Skala von 0 bis 10:

| Prinzip | Gewicht | Was gemessen wird (Auswahl) |
| --- | --- | --- |
| Modularität | 45 % | Abbildung der Soll- auf die Ist-Architektur, klare Verantwortlichkeiten der Bausteine, ausgewogene Größen, Anteil Code in großen Klassen und Methoden |
| Hierarchie | 30 % | Architekturverletzungen in Schichtung und fachlicher Struktur, Anteil Klassen und Pakete in Zyklen, Größe der Zyklen |
| Musterkonsistenz | 25 % | Anteil Code, der den geplanten Mustern folgt, Trennung von fachlichem und technischem Code |

So lest ihr den Wert: Zwischen 8 und 10 ist das System in guter Verfassung. Es hat wenige Schulden, und der Aufwand für Wartung bleibt planbar. Zwischen 4 und 8 haben sich Schulden angesammelt, Änderungen werden spürbar teurer. Gezielte Refactorings bringen das System zurück in den oberen Korridor. Unter 4 ist jede Änderung teuer und riskant. Dann muss abgewogen werden, ob eine Sanierung noch lohnt oder ein Neubau günstiger ist.

![Die drei MMI-Korridore auf der Skala von 0 bis 10: 8 bis 10 geringe Schulden und planbare Wartung, 4 bis 8 angesammelte Schulden mit nötigen Refactorings, 0 bis 4 stark erodiert mit der Frage Sanieren oder Ersetzen](https://www.mpowr-it.de/hs-fs/hubfs/Blog/Grafiken/mmi-korridore.png?v=20261109a&width=1600&name=mmi-korridore.png)

Die drei MMI-Korridore, Schwellen nach Carola Lilienthal, Langlebige Software-Architekturen.

Ähnlich einfach sind die Schwellen für Zyklen: Hängen weniger als 10 % der Klassen in Zyklen, ist alles in Ordnung. Bei 10 bis 20 % wartet Arbeit, ab 30 % ist die Architektur stark erodiert. Für Pakete gelten weitere Grenzen: bis 20 % ist in Ordnung, über 40 % ein ernstes Problem.

**Kopplungsmetriken.** Ford und Kollegen greifen auf Metriken zurück, die es seit Jahrzehnten gibt und die jede Plattform mit Werkzeugen unterstützt. Afferente Kopplung zählt, wie viele andere Komponenten von einer Komponente abhängen. Efferente Kopplung zählt umgekehrt, von wie vielen anderen Komponenten sie selbst abhängt. Aus beiden Zahlen ergibt sich die Instabilität: Eine Komponente, die von vielen anderen abhängt, aber selbst kaum genutzt wird, ist instabil und bricht leicht, wenn sich ihre Umgebung ändert. Eine Komponente, auf die viele andere angewiesen sind, sollte dagegen stabil bleiben und sich selten ändern. Setzt man die Instabilität ins Verhältnis zur Abstraktheit, also zum Anteil an Schnittstellen und abstrakten Klassen, zeigt sich, ob eine Komponente ausgewogen gebaut ist: Stabile Komponenten sollten abstrakt sein, instabile konkret. Komponenten, die aus dieser Balance fallen, landen entweder in der Zone der Nutzlosigkeit (sehr abstrakt, aber von niemandem gebraucht) oder in der Zone des Schmerzes (viel konkrete Implementierung, von vielen genutzt und deshalb kaum änderbar). Wenn viele Komponenten in einer dieser Zonen liegen, ist das ein Hinweis darauf, dass die interne Struktur zuerst repariert werden muss, bevor ein Umbau überhaupt lohnt.

Eine wiederkehrende Warnung: Alles, was Werkzeuge finden, ist ein Indiz, keine Wahrheit. Die Zahlen gehören ins Teamgespräch, nicht in ein Dashboard für die Geschäftsführung.

## Technische Schulden reduzieren: in drei Phasen

Wir durchlaufen mit euch drei Phasen, wenn wir an System- und Software-Architektur arbeiten:

**Phase 1 – Aufräumen:** Soll- und Ist-Architektur werden nebeneinandergelegt. Fast immer weicht der Code vom Plan ab, oft überraschend für das Team. Diese Abweichungen werden repariert, und die Soll-Architektur wird um fehlende Konzepte ergänzt. Für komplexere Systeme braucht es dafür in der Regel einen Workshop von zwei oder mehr Tagen, kleinere Systeme lassen sich an einem Tag aufräumen.

**Phase 2 - Verbessern:** Jetzt werden die eigentlichen Refactorings definiert, priorisiert und in die laufende Entwicklung eingeplant. Diese Phase steht und fällt mit Freiräumen und es gibt verschiedenste Ansätze, diese Freiräume zu schaffen: Zum Beispiel nach jedem Release vier Wochen ohne neue Features, nur Aufräumen und Architektur. Oder: Dedizierte Task-Forces, die sich nur um das Aufräumen kümmern. Das ist natürlich abhängig von Team-Stärke und Aufwand, aber null Freiraum geht nicht. Wichtig ist, dass sich bereits die ersten Quick-Wins in schnellerer Wartung bemerkbar machen, und solche Qualitätsarbeiten sind fast immer günstiger als eine Neuentwicklung, so verlockend sie auch wirkt.

**Phase 3 - Erhalten:** Das Team hält die eigenen Architektur-Vorgaben mit Werkzeugen und Regeln selbst in einem vertretbaren Korridor. Wie Leitplanken einer Autobahn sollen sie einen Weg schaffen, der unterschiedliche Geschwindigkeiten erlaubt und Sicherheit vor Ausreißern gibt. Steht eine größere Änderung an, geht es bewusst zurück in Phase 2, damit die Architektur nachhaltig gestärkt wird.

**Wann zerlegen, wann nicht.** Wenn ein Monolith zur Wachstumsbremse wird, ist die Versuchung groß, ihn in Microservices zu zerschneiden. Aber Achtung: Ohne klaren geschäftlichen Treiber wie Time-to-Market, Skalierbarkeit oder Ausfalltoleranz sollte man nicht einfach alles zerlegen. Und wenn, dann methodisch. Sechs komponentenbasierten Zerlegungsmuster führen schrittweise von der Komponentenstruktur zu Domänen-Services, die als Zwischenschritt oder Endzustand taugen, ohne dass die Datenbank sofort aufgeteilt werden muss:

![Komponentenbasierte Zerlegung: Vom Monolithen über das Identifizieren und Dimensionieren von Komponenten, das Bündeln gemeinsamer Domänenkomponenten, das Verflachen, das Bestimmen der Abhängigkeiten und das Bilden von Domänen zu Domänen-Services und schließlich Microservices.](https://www.mpowr-it.de/hs-fs/hubfs/Blog/Grafiken/komponentenbasierte-zerlegung.png?v=20261109b&width=1600&name=komponentenbasierte-zerlegung.png)

Darstellung nach Ford, Richards, Sadalage & Dehghani, Software Architecture: The Hard Parts, Abb. 5–1.

Jedes Muster bringt eigene Fitness Functions mit, die nach dem Umbau prüfen, dass die Struktur hält, etwa dass keine Komponente mehr als einen bestimmten Anteil des Codes ausmacht oder dass kein verwaister Quellcode herumliegt. Unser pragmatischer Ansatz sind Architektur-Storys, die eine strukturelle Änderung mit ihrem geschäftlichen Treiber verbinden, getrennt von den üblichen „Aufräumen“-Tickets. So bekommt Architekturarbeit Priorität, statt am Ende übrig zu bleiben.

## Technische Schulden verhindern: Leitplanken, die im Alltag halten

Reduzieren allein reicht nicht. Ohne Leitplanken erodiert die Architektur wieder, nur diesmal mit einem Team, das die Hoffnung verloren hat. Vier Maßnahmen haben sich bewährt:

**Architecture Decision Records (ADRs):** Eine Entscheidung, die schwer zu ändern ist, bekommt ein ein- bis zweiseitiges Dokument mit drei Abschnitten: Kontext (welches Problem, welche Alternativen), Entscheidung (was und warum), Konsequenzen (welche Trade-offs). Das löst die Dokumentationsschuld an der Stelle, an der sie am meisten kostet, und macht die Architektur für neue Teammitglieder und KI-Agenten lesbar.

**Fitness Functions.** Eine Fitness Function ist jeder Mechanismus, der eine Architektureigenschaft objektiv prüft. Der Klassiker ist ein Test im Build, der fehlschlägt, sobald zyklische Abhängigkeiten zwischen Paketen entstehen. Ein zweiter prüft, dass Controller nur auf Services zugreifen und Services nur auf Persistenz, mit Werkzeugen wie ArchUnit oder NetArchTest. Das ist vergleichbar mit der Checkliste von Chirurgen und Piloten: nicht weil die Profis ihren Job nicht kennen, sondern weil unter Druck gern Schritte übersprungen werden. Man sollte es aber nicht übertreiben; eine Handvoll kuratierter Regeln, die wirklich aussagekräftig sind, schlägt ein komplexes Geflecht, das Entwickler nur frustriert.

**Architektur als Holschuld im Team.** Wir empfehlen regelmäßige Architekturdiskussionen, Pair Programming mit wechselnden Paaren, gemeinsame Refactorings am großen Bildschirm und Live-Workshops, in denen das Team seine Architektur selbst anfasst. Nur wer die Architektur kennt, kann sie erhalten.

**Monitoring und Tests.** Kennzahlen wie Zyklen, Kopplung und Klassengrößen werden automatisiert erhoben, damit Abweichungen auffallen, solange sie klein sind. Und automatisierte Tests sind keine Option, sondern die Voraussetzung dafür, dass Refactorings gefahrlos möglich bleiben.

## Beleg aus der Praxis: Digistore24

Das technische Setup von Digistore24 war über 15 Jahre mit dem Unternehmen gewachsen. Unterschiedliche Build-Konfigurationen hatten zu vielen Docker-Image-Varianten geführt, große Images verlängerten Übertragungs- und Laufzeiten, und bei rund 60.000 CI/CD-Jobs pro Monat wurde diese Komplexität zu einem wirtschaftlichen Faktor. Das Team hatte Respekt davor, im laufenden Betrieb daran zu schrauben.

Wir sind nicht mit dem großen Umbau gestartet, sondern mit einem gemeinsamen Assessment. Danach haben wir Schritt für Schritt aufgeräumt: ein Image pro Anwendung mit klar definierten Build-Targets statt separater Images je Umgebung, minimale und gehärtete Basis-Images, schnellere Runner für die rechenintensiven Jobs. Das Ergebnis: 30 % weniger Images, die das Team pflegt, 45 % kleinere Images, 71 % kürzere Build- und CI-Workflows und 77 % geringere CI/CD-Kosten pro Monat.

Der Teil, der Schulden dauerhaft verhindert, war aber ein anderer: eine KI-freundliche Dockerfile-Guideline, aus der bei Digistore24 ein eigener KI-Skill für das Erstellen und Pflegen von Images entstanden ist. Standards, Dokumentation und Leitplanken bleiben im Team, und das Team entwickelt sein Setup heute selbst weiter.

## Wie wir euch dabei unterstützen

Unser Architektur-Review beginnt mit Messen: Systemgröße, Kopplung, Zyklen, Soll gegen Ist. Daraus entsteht ein Bild, das Entwickler und Geschäftsführung gleichermaßen verstehen, und eine priorisierte Liste von Refactorings mit Aufwand und Nutzen. Die Umsetzung begleiten wir gemeinsam mit eurem Team, dokumentiert in ADRs und abgesichert durch Fitness Functions, damit die Architektur danach überprüfbar bleibt und nicht wieder nur zum Bauchgefühl wird.

[Mehr zu System- und Softwarearchitektur](https://www.mpowr-it.de/leistungen/system-und-softwarearchitektur?hsLang=de)

[Jetzt Erstgespräch vereinbaren→](https://www.mpowr-it.de/termin-vereinbaren?hsLang=de)

## Quellen und weiterführende Literatur

- Carola Lilienthal: [Langlebige Software-Architekturen](https://link.amazon/B0hmmy0xd). Technische Schulden analysieren, begrenzen und abbauen. dpunkt.verlag.
- Neal Ford, Mark Richards, Pramod Sadalage, Zhamak Dehghani: [Software Architecture: The Hard Parts](https://link.amazon/B08FhQmsX). Modern Trade-Off Analyses for Distributed Architectures. O'Reilly.
- Kundenreferenz: [Komplexität raus. Geschwindigkeit rein. Digistore24](https://www.mpowr-it.de/blog/kundenreferenz/digistore24-mpowr-it?hsLang=de)
- Beitrag 1 dieser Reihe: [Warum euer Entwicklungsteam langsamer wird - und was dagegen hilft](https://www.mpowr-it.de/blog/entwicklungsgeschwindigkeit?hsLang=de)

![Holger Woltersdorf](https://www.mpowr-it.de/hs-fs/hubfs/holger-woltersdorf.webp?width=64&height=64&name=holger-woltersdorf.webp)

[Holger Woltersdorf](https://www.mpowr-it.de/blog/author/holger-woltersdorf) 16. November 2026

Gründer und Geschäftsführer von MPOWR IT, ist System- und Softwarearchitekt, leidenschaftlicher Entwickler und Team-Enabler. Er hat über 20 Jahre Erfahrung als Entwickler und Teamleiter in den Bereichen Mobilfunk, Mode und Lebensmittel-E-Commerce sowie in weiteren Branchen.

<https://de.linkedin.com/in/holger-woltersdorf>

## Erstgespräch direkt online buchen.

Wähle einen passenden Termin – unkompliziert und ohne Umwege.

Das Gespräch findet online statt – den Link erhältst du nach der Buchung automatisch per E-Mail.

- [Erstgespräch buchen](https://www.mpowr-it.de/termin-vereinbaren?hsLang=de)
- [Zum Kontaktformular](https://www.mpowr-it.de/kontakt?hsLang=de)

Weiterlesen

## Mehr aus dem Blog

[![Ein Netzwerkkabel-Stecker zieht vergeblich an seinem Kabel, das unter einem Felsbrocken mit der Aufschrift Technical Debt eingeklemmt ist](https://www.mpowr-it.de/hs-fs/hubfs/Blog/Grafiken/titelbild-entwicklungsgeschwindigkeit.png?v=20261109b&width=560&height=315&name=titelbild-entwicklungsgeschwindigkeit.png)](https://www.mpowr-it.de/blog/entwicklungsgeschwindigkeit?hsLang=de)

### [Warum euer Entwicklungsteam langsamer wird - und was dagegen hilft](https://www.mpowr-it.de/blog/entwicklungsgeschwindigkeit?hsLang=de)

Das Team ist in zwei Jahren von vier auf zehn Entwickler gewachsen. Trotzdem dauert ein Feature, das früher in einer Woche fertig...

[Beitrag lesen→](https://www.mpowr-it.de/blog/entwicklungsgeschwindigkeit?hsLang=de)

[![TRICERA Energy Kundenprojekt für Batteriespeichersysteme](https://www.mpowr-it.de/hs-fs/hubfs/customer-cases/tricera-kundenreferenz-mpowrit.webp?width=560&height=315&name=tricera-kundenreferenz-mpowrit.webp)](https://www.mpowr-it.de/blog/kundenreferenz/tricera-energy-mpowr-it?hsLang=de)

Kundenreferenz

### [Skalierbare IoT-Edge-Architektur für TRICERA Energy](https://www.mpowr-it.de/blog/kundenreferenz/tricera-energy-mpowr-it?hsLang=de)

MPOWR IT stärkte bei TRICERA Energy Softwareteam, Golang-Architektur, MQTT-Datenflüsse und Kubernetes-Infrastruktur für...

[Beitrag lesen→](https://www.mpowr-it.de/blog/kundenreferenz/tricera-energy-mpowr-it?hsLang=de)

[![Digistore24 CI/CD-Optimierung durch MPOWR IT](https://www.mpowr-it.de/hs-fs/hubfs/kundenlogo-digistore24.png?width=560&height=315&name=kundenlogo-digistore24.png)](https://www.mpowr-it.de/blog/kundenreferenz/digistore24-mpowr-it?hsLang=de)

Kundenreferenz

### [Komplexität raus. Geschwindigkeit rein.](https://www.mpowr-it.de/blog/kundenreferenz/digistore24-mpowr-it?hsLang=de)

Wie MPOWR IT bei Digistore24 die CI/CD-Kosten um rund 77 % senkte, Docker-Images verkleinerte und die Build-Pipelines...

[Beitrag lesen→](https://www.mpowr-it.de/blog/kundenreferenz/digistore24-mpowr-it?hsLang=de)

![MPOWR IT Logo](https://www.mpowr-it.de/hubfs/Downloads/mpowr-logo.svg)

The Systems and Software Architects

## Partnerschaften

[![Partner von MPOWR IT: skriptfabrik](https://www.mpowr-it.de/hs-fs/hubfs/Partner/skriptfabrik.png?width=600&height=250&name=skriptfabrik.png)](https://www.skriptfabrik.com/de/) [![Partner von MPOWR IT: move elevator](https://www.mpowr-it.de/hs-fs/hubfs/Partner/move-elevator.png?width=1200&height=360&name=move-elevator.png)](https://www.move-elevator.de/) [![Partner von MPOWR IT: Denktmit](https://www.mpowr-it.de/hubfs/Partner/denktmit-logo.svg)](https://denktmit.de/) [![Partner von MPOWR IT: PHP USERGROUP](https://www.mpowr-it.de/hubfs/Partner/phpugdd-logo.svg)](https://phpug-dresden.org/index.html)

 LEISTUNGEN

- [IT-Strategieberatung](https://www.mpowr-it.de/leistungen/it-strategieberatung?hsLang=de)
- [Technical Due Diligence](https://www.mpowr-it.de/leistungen/tech-due-diligence?hsLang=de)
- [Softwarearchitektur](https://www.mpowr-it.de/leistungen/system-und-softwarearchitektur?hsLang=de)
- [IT & Cloud Security](https://www.mpowr-it.de/leistungen/it-cloud-security?hsLang=de)
- [KI-Readiness-Check](https://www.mpowr-it.de/leistungen/ai-readiness-assessment?hsLang=de)
- [AI Readiness Assessment](https://www.mpowr-it.de/leistungen/ai-readiness-assessment?hsLang=de)
- [IAM](https://www.mpowr-it.de/leistungen/identity-access-management?hsLang=de)

 MPOWR IT

- [LinkedIn](https://www.linkedin.com/company/mpowr-it)
- [Über Uns](https://www.mpowr-it.de/ueber-uns?hsLang=de)
- [Fakten](https://www.mpowr-it.de/mpowr-it-fakten?hsLang=de)

 Rechtliches

- [Impressum](https://www.mpowr-it.de/impressum?hsLang=de)
- [Datenschutz](https://www.mpowr-it.de/datenschutz?hsLang=de)
- [AGB](https://www.mpowr-it.de/agb?hsLang=de)

© 2026 MPOWR IT GmbH. ALL RIGHTS RESERVED.

<https://www.linkedin.com/company/mpowr-it> <https://github.com/mpowr-it>

```json
{
  "@context" : "https://schema.org",
  "@id" : "https://www.mpowr-it.de/#organization",
  "@type" : [ "Organization", "ProfessionalService" ],
  "address" : {
    "@type" : "PostalAddress",
    "addressCountry" : "DE",
    "addressLocality" : "Dresden",
    "postalCode" : "01277",
    "streetAddress" : "Enderstr. 94"
  },
  "email" : "hello@mpowr-it.de",
  "logo" : {
    "@type" : "ImageObject",
    "url" : "https://147718780.fs1.hubspotusercontent-eu1.net/hubfs/147718780/MPOWR-IT-2026/Home/Logo.svg"
  },
  "name" : "MPOWR IT GmbH",
  "sameAs" : [ "https://www.linkedin.com/company/mpowr-it", "https://github.com/mpowr-it" ],
  "url" : "https://www.mpowr-it.de/",
  "vatID" : "DE359347772"
}
```

```json
{
  "@context" : "https://schema.org",
  "@id" : "https://www.mpowr-it.de/#website",
  "@type" : "WebSite",
  "inLanguage" : "de-DE",
  "name" : "MPOWR IT",
  "publisher" : {
    "@id" : "https://www.mpowr-it.de/#organization"
  },
  "url" : "https://www.mpowr-it.de/"
}
```

```json
{
  "@context" : "https://schema.org",
  "@id" : "https://www.mpowr-it.de/blog/technische-schulden#webpage",
  "@type" : "WebPage",
  "description" : "Warum technische Schulden entstehen, wie ihr sie objektiv messt (MMI, Kopplungsmetriken), in drei Phasen abbaut und mit ADRs und Fitness Functions dauerhaft verhindert.",
  "inLanguage" : "de-DE",
  "isPartOf" : {
    "@id" : "https://www.mpowr-it.de/#website"
  },
  "name" : "Technische Schulden reduzieren und verhindern | MPOWR IT",
  "publisher" : {
    "@id" : "https://www.mpowr-it.de/#organization"
  },
  "url" : "https://www.mpowr-it.de/blog/technische-schulden"
}
```

```json
{
  "@context" : "https://schema.org",
  "@type" : "BlogPosting",
  "author" : {
    "@type" : "Person",
    "name" : "Holger Woltersdorf",
    "url" : "https://www.mpowr-it.de/blog/author/holger-woltersdorf"
  },
  "dateModified" : "2026-11-16T07:00:01.727Z",
  "datePublished" : "2026-11-16T07:00:00.000Z",
  "headline" : "Technische Schulden reduzieren und verhindern | MPOWR IT",
  "image" : [ "https://www.mpowr-it.de/hubfs/Blog/Grafiken/titelbild-technische-schulden.png?v=20261109b" ],
  "mainEntityOfPage" : {
    "@id" : "https://www.mpowr-it.de/blog/technische-schulden",
    "@type" : "WebPage"
  },
  "publisher" : {
    "@type" : "Organization",
    "logo" : {
      "@type" : "ImageObject",
      "url" : "https://www.mpowr-it.de/hubfs/mpowrit_logo.svg"
    }
  }
}
```