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

Micro­ser­vices oder Monolith: Entschei­dungs­hilfe für Teams und Produkte

Microservices gelten als modern, doch für viele Produkte ist ein modularer Monolith die bessere Wahl. So wägen Sie Teams, Releases, Datenkonsistenz und Betriebskosten realistisch ab.

Beitragsbild: Microservices oder Monolith: Entscheidungshilfe für Teams und Produkte

Starten Sie mit einem modularen Monolithen und lösen Sie einzelne Teile erst dann als Microservices heraus, wenn ein konkreter Grund vorliegt: mehrere Teams, die sich bei Releases blockieren, ein Bereich mit deutlich anderem Skalierungs- oder Verfügbarkeitsbedarf oder eine technisch abweichende Komponente. Microservices sind kein Qualitätsmerkmal, sondern ein Werkzeug mit spürbaren Betriebskosten.

Große Plattformen zeigen, was verteilte Services leisten. Doch was für Konzerne mit hunderten Entwicklern funktioniert, ist für ein mittelständisches Produkt oft unnötig komplex und teuer im Betrieb. Dieser Beitrag liefert eine belastbare Entscheidungshilfe: einen Vergleich, Kriterien, typische Irrtümer und einen Weg, Schritt für Schritt von einem Monolithen zu Services zu kommen.

Zwei Archi­tek­turen im Überblick

Ein Monolith ist eine Anwendung, die als Ganzes gebaut und ausgeliefert wird. Alle Funktionen – etwa Benutzerverwaltung, Bestellungen und Abrechnung – laufen in einem Prozess und teilen sich in der Regel eine Datenbank. Bei Microservices wird die Anwendung in eigenständige Dienste zerlegt. Jeder Service verantwortet einen fachlichen Bereich, hat oft eine eigene Datenhaltung und wird unabhängig ausgeliefert. Die Kommunikation läuft über Schnittstellen oder Nachrichten.

Dazwischen liegt der modulare Monolith: eine Anwendung, die als Einheit betrieben wird, intern aber in klar abgegrenzte Module gegliedert ist. Die folgende Übersicht stellt ihn den Microservices gegenüber.

KriteriumModularer MonolithMicroservices
Deploymenteine Einheit, ein Build, ein Rollbackje Service eigene Pipeline und Version; Abstimmung bei übergreifenden Änderungen
DatenkonsistenzTransaktionen in einer Datenbankverteilte Daten; Abgleich über Ereignisse, Sagas und eventuelle Konsistenz
Skalierungdie ganze Anwendung horizontal; Teile nicht getrennteinzelne Services unabhängig skalierbar
Fehlersucheein Stack, ein Log, ein Debuggerverteiltes Tracing über mehrere Dienste nötig
Teamautonomiebegrenzt: gemeinsamer Code, gemeinsames Releasehoch, sofern die fachlichen Grenzen stabil sind
Betriebsaufwandgering bis mittelhoch: mehr Infrastruktur, Netzwerk, Monitoring und Sicherheit je Dienst
Lokale Entwicklungeinfachaufwendiger: mehrere Dienste, Testdaten, Mocks
Geeignet fürein Team oder wenige Teams, Produkte im Aufbaumehrere unabhängige Teams, stark unterschiedliche Anforderungen je Bereich

Der Monolith ist keine Schande

Ein klar geschichteter Monolith mit sauberen Modulgrenzen ist für viele Produkte die kosteneffizienteste Startform. Das hat handfeste Gründe:

  • Einfache Deployments: ein Build, eine Auslieferung, ein Rollback.
  • Nachvollziehbare Transaktionen: Änderungen über eine Datenbank bleiben konsistent, ohne verteilte Abstimmung.
  • Fokussierte Fehleranalyse: Logs, Metriken und Debugging konzentrieren sich auf einen Stack.
  • Geringerer Betriebsaufwand: weniger Infrastruktur, weniger Netzwerk, weniger bewegliche Teile.

Wichtig ist das Wort „modular“. Ein Monolith ohne innere Struktur wird mit der Zeit zum schwer wartbaren Geflecht. Selbst große Technologieunternehmen haben öffentlich beschrieben, einzelne Dienste wieder zusammenzuführen, weil der Betriebsaufwand den Nutzen überstieg – ein Hinweis darauf, dass die Frage keine Glaubensfrage ist, sondern eine Abwägung.

So bleibt ein Monolith modular

  • Module nach fachlichen Domänen schneiden, etwa Benutzer, Bestellungen und Abrechnung – nicht nach technischen Schichten
  • Zugriff auf ein Modul nur über dessen definierte öffentliche Schnittstelle zulassen
  • Tabellen oder Schemata je Modul trennen und keine Abfragen über Modulgrenzen hinweg schreiben
  • Architekturtests in der Pipeline, die verbotene Abhängigkeiten melden – etwa mit ArchUnit, Deptrac oder dependency-cruiser
  • Nebenwirkungen zwischen Modulen über interne Ereignisse statt direkte Aufrufe abbilden

Wann Micro­ser­vices Sinn ergeben

Services spielen ihre Stärken aus, wenn Organisation und Anforderungen es verlangen. Software-Architektur spiegelt oft die Kommunikationsstruktur der Organisation wider (Conways Gesetz). Wenn mehrere Teams an einer Codebasis arbeiten und sich ständig abstimmen müssen, kann eine Aufteilung entlasten. Typische Anzeichen:

  • Mehrere Teams sollen unabhängig voneinander entwickeln und ausliefern.
  • Bereiche haben sehr unterschiedliche Release-Zyklen, etwa ein Preismodul, das laufend angepasst wird, und ein CMS-Frontend mit seltenen Änderungen.
  • Einzelne Funktionen müssen deutlich stärker skalieren als der Rest.
  • Eine rechenintensive Komponente braucht eine andere Programmiersprache oder Laufzeitumgebung.
  • Domänen haben unterschiedliche Anforderungen an Verfügbarkeit und Service-Level.

Die Kosten verteilter Systeme

Microservices sind nicht umsonst zu haben. Verteilte Transaktionen erfordern Muster wie Sagas oder die Akzeptanz eventueller Konsistenz, Nachrichten müssen idempotent verarbeitet werden. Netzwerkaufrufe bringen Latenz und neue Fehlerquellen mit sich. Monitoring, Tracing, Service-Discovery und Deployment-Automatisierung werden Pflicht. Jede Schnittstelle zwischen Services braucht einen stabilen Vertrag und eine Versionierung – wie das gelingt, zeigt der Beitrag REST-APIs mit OpenAPI. Auch das lokale Entwickeln und Testen wird aufwendiger, wenn für einen Testlauf mehrere Dienste laufen müssen. Ohne ausgereifte DevOps-Praxis entsteht schnell ein „verteilter Monolith“: Dienste, die nur gemeinsam geändert und ausgeliefert werden können – mit den Nachteilen beider Welten.

Eine Faustregel aus der Praxis: Bevor Sie Services schneiden, sollten Sie einen Monolithen automatisiert bauen, testen, überwachen und zurückrollen können. Gelingt das dort nicht, wird es verteilt nicht leichter.

Entschei­dungs­hilfe in fünf Fragen

  1. Teamstruktur: Gibt es mehrere Teams, die sich bei Releases gegenseitig blockieren?
  2. Skalierung: Muss ein Teil des Systems unabhängig und deutlich stärker skalieren?
  3. Service-Level: Haben Domänen unterschiedliche Anforderungen an die Verfügbarkeit?
  4. Betrieb: Verfügen Sie über die Kompetenzen und Werkzeuge für verteilte Systeme?
  5. Fachliche Grenzen: Sind die Domänen stabil genug, um sie dauerhaft zu trennen?

Lautet die Antwort auf die ersten drei Fragen überwiegend „nein“, ist ein modularer Monolith in aller Regel die bessere Wahl. Frage fünf ist die Bremse für überstürzte Entscheidungen: Wer die fachlichen Grenzen noch nicht kennt, schneidet sie zwangsläufig falsch – und falsch geschnittene Services sind teurer zu korrigieren als Module in einem Monolithen.

Drei verbreitete Irrtümer

„Micro­ser­vices skalieren automatisch besser“

Skalierbarkeit entsteht durch saubere Architektur, Caching und eine passende Datenhaltung – nicht allein durch die Aufteilung in Services. Auch ein gut gebauter Monolith lässt sich horizontal skalieren, indem mehrere Instanzen hinter einem Load Balancer laufen. Wie Sie Engpässe finden, bevor Sie die Architektur ändern, zeigt der Beitrag Cloud-Skalierung für Plattformen.

„Mit Services werden wir schneller“

Das gilt nur, wenn Teams tatsächlich unabhängig arbeiten können. Müssen für jede neue Funktion drei Services gleichzeitig angepasst und abgestimmt ausgeliefert werden, sinkt das Tempo, statt zu steigen.

„Einen Monolithen bekommt man nie wieder auseinander“

Mit klaren Modulgrenzen und dem passenden Vorgehen ist das durchaus möglich. Entscheidend ist, dass die innere Struktur von Anfang an gepflegt und nicht dem Termindruck geopfert wird.

Vom Monolithen zu Services: das Strangler-Muster

Wächst der Bedarf, lässt sich ein Modul gezielt als Service herauslösen. Dieses schrittweise Vorgehen, oft als Strangler-Muster bezeichnet, senkt das Risiko erheblich, weil das bestehende System weiterläuft, während einzelne Teile ersetzt werden. In der Praxis hat sich diese Reihenfolge bewährt:

  1. Kandidat wählen: ein Bereich mit eigenem Skalierungs-, Release- oder Verfügbarkeitsbedarf und klar abgegrenzten Daten, etwa Bildverarbeitung, ein Importdienst oder die Synchronisation für eine mobile App.
  2. Schnittstelle definieren: einen API-Vertrag oder Ereignisse festlegen und das Modul im Monolithen zunächst hinter dieser Schnittstelle kapseln.
  3. Daten trennen: eigene Tabellen oder Datenbank für den Service, Synchronisation bewusst planen. Das ist meist der aufwendigste Schritt.
  4. Verkehr schrittweise umleiten: über einen Proxy oder Feature-Flag, zunächst parallel betreiben und Ergebnisse vergleichen.
  5. Alten Code entfernen: erst wenn der Service stabil läuft, den ursprünglichen Teil im Monolithen löschen.

Wie Sie bei bestehenden Systemen entscheiden, was zuerst angegangen wird, hängt auch von Altlasten ab. Eine Bewertungsmethode zeigt der Beitrag Technical Debt priorisieren.

Praxis­bei­spiele und Checkliste

Zwei Szenarien aus dem Mittelstand

Beispiel 1: Kundenportal. Angenommen, ein Dienstleister baut ein Portal mit Benutzerverwaltung, Auftragsdaten, Dokumenten, Abrechnung und Schnittstellen zu Drittsystemen. Ein kleines Team entwickelt es als modularen Monolithen mit klaren Modulgrenzen. Ein Jahr später kommt eine mobile App mit Offline-Funktion hinzu. Deren Synchronisation erzeugt andere Lastspitzen und ändert sich häufiger als der Rest. Jetzt lohnt sich ein eigener Synchronisationsdienst – der Rest des Portals bleibt unverändert.

Beispiel 2: gewachsene Branchensoftware. An einem Monolithen arbeiten drei Teams, Releases erfolgen nur gemeinsam und müssen aufwendig abgestimmt werden. Hier beginnt die Lösung nicht mit Services, sondern mit Modulgrenzen und Architekturtests im vorhandenen Code. Erst wenn ein Bereich – etwa die Preisberechnung – sauber getrennt ist und einen eigenen Release-Rhythmus braucht, wird er nach dem Strangler-Muster herausgelöst.

Checkliste vor der Entscheidung

  • Fachliche Domänen und ihre Grenzen sind beschrieben.
  • Die Team- und Release-Struktur der nächsten Jahre ist absehbar.
  • Skalierungs- und Verfügbarkeitsanforderungen sind je Bereich bekannt.
  • Der Monolith lässt sich automatisiert bauen, testen und zurückrollen.
  • Betriebskompetenz für Monitoring, Tracing und Automatisierung ist vorhanden oder eingeplant.
  • Die Gesamtkosten für Entwicklung und Betrieb sind für beide Varianten grob geschätzt.

So unterstützt Nano Concepts

Bei neuen Anwendungen für mittelständische Unternehmen – etwa Portalen mit Benutzerverwaltung, Datenpflege und Schnittstellen zu Drittsystemen – empfehlen wir in der Regel den modularen Monolithen als Start. Erst wenn ein Bereich nachweislich andere Anforderungen hat, lohnt sich ein eigenständiger Dienst. Wir unterstützen Sie bei der Architekturentscheidung im Rahmen der Tech-Beratung, setzen neue Anwendungen in der Softwareentwicklung um und führen bestehende Systeme mit der Software-Modernisierung schrittweise in eine tragfähige Struktur. Im kostenlosen Erstgespräch klären wir, welche Architektur zu Ihrem Team und Ihren Zielen passt.

Häufige Fragen

Nicht grundsätzlich. Microservices lohnen sich bei mehreren unabhängigen Teams, stark unterschiedlichem Skalierungsbedarf oder verschiedenen Service-Levels. Dafür verursachen sie mehr Betriebsaufwand, komplexere Fehlersuche und aufwendigere Datenkonsistenz. Für viele Produkte ist ein modularer Monolith einfacher, schneller und kostengünstiger zu betreiben.

Eine Anwendung, die als eine Einheit gebaut und betrieben wird, intern aber in fachlich getrennte Module mit definierten Schnittstellen gegliedert ist. Module greifen nicht direkt auf die Daten anderer Module zu. So bleibt der Code verständlich, und einzelne Module lassen sich später bei Bedarf als eigene Services herauslösen.

Wenn konkrete Gründe vorliegen: Mehrere Teams blockieren sich bei Releases, ein Bereich muss deutlich stärker oder anders skaliert werden, Domänen brauchen unterschiedliche Verfügbarkeit oder eine Komponente erfordert eine andere Technologie. Zusätzlich müssen Monitoring, Tracing und Deployment-Automatisierung vorhanden sein.

Ja. Beim Strangler-Muster werden einzelne Bereiche nach und nach herausgelöst und der Verkehr schrittweise umgeleitet, während das bestehende System weiterläuft. Das reduziert das Risiko gegenüber einer kompletten Neuentwicklung. Am Anfang stehen meist klare Modulgrenzen im vorhandenen Code.

Das hängt von Größe, Kopplung der Daten, Testabdeckung und Betriebsreife ab. Teuer sind meist nicht die Services selbst, sondern das Trennen der Datenbank, der Aufbau von Pipelines, Monitoring und Schnittstellenverträgen sowie der laufende Betrieb. Eine Bestandsaufnahme der Architektur schafft eine belastbare Grundlage für die Schätzung.

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: Micro­ser­vices vs. Monolith

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

Projekt anfragen