SaaS-Apps skalieren: Architektur und Performance

Die meisten SaaS-Apps brechen nicht zusammen, weil der Code schlecht ist. Sie brechen zusammen, weil die Architektur, die dich zu 100 Kunden gebracht hat, 10.000 nicht tragen kann. Dieser Leitfaden geht die Hebel durch, die beim Skalieren einer SaaS-Anwendung wirklich etwas bewegen, in der Reihenfolge, in der du sie ziehen solltest.

5 Min. Lesezeit7 Abschnitte22. Juni 2026

Geschrieben von

Kostadin Stamboliev

Gründer und Imaginator

Gründer und Imaginator von Pineido. Arbeitet in IT-Beratung, App- und Webentwicklung, technischem SEO sowie KI und Automatisierung. Liefert Produktionscode in 30-Tage-Sprints mit festem Umfang und klarer Verantwortung.

LinkedIn

Performance und Skalierbarkeit sind nicht dasselbe Problem

Es lohnt sich, präzise zu sein, denn Teams verschwenden Monate damit, beides zu verwechseln. Performance ist, wie reaktionsschnell dein System mit den Ressourcen ist, die es genau jetzt hat. Wenn du eine Abfrage cachst, eine Nutzlast kürzt oder einen Index hinzufügst, hast du die Performance verbessert. Skalierbarkeit ist, ob diese Reaktionsfähigkeit erhalten bleibt, wenn sich der Traffic verdoppelt und dann erneut verdoppelt. Ein Dienst kann schnell und nicht skalierbar sein, etwa ein Endpunkt, der in 2ms antwortet, aber bei 100 Anfragen pro Sekunde umkippt. Die beiden Kennzahlen, die zählen, sind Latenz (Zeit pro Anfrage, verfolgt als p50, p95, p99) und Durchsatz (pro Sekunde verarbeitete Anfragen). Performance-Tuning hat eine Decke. Steigt die Last, kriecht die Latenz nach oben und schießt dann hoch, und jenseits dieses Punktes hält dich nur echte Kapazität am Leben, also mehr oder größere, gut genutzte Maschinen. Die praktische Regel: optimiere die Performance, bis du an die Wand stößt, und entwirf dann für Skalierung. Springe nicht direkt dazu über, Infrastruktur hinzuzufügen, denn langsamer Code auf mehr Servern ist nur teurer langsamer Code.

Wähle ein Mandantenmodell bewusst, nicht standardmäßig

Mandantenfähigkeit ist die Architekturentscheidung, die alles Nachgelagerte prägt. Es gibt drei Muster. Pool (geteiltes Schema) hält alle Mandanten in denselben Tabellen, getrennt durch eine tenant_id-Spalte, und ist am ressourceneffizientesten. Bridge (Schema pro Mandant) gibt jedem Mandanten ein Schema in einer Datenbank, mit stärkerer Isolation, aber schwierigeren Migrationen über N Schemata hinweg. Silo (Datenbank pro Mandant) gibt jedem Mandanten eine eigene Datenbank, die stärkste Isolation und im Betrieb am teuersten. Die Falle ist, dies als eine globale Wahl zu behandeln. Das Muster, zu dem die meisten reifen SaaS-Teams 2025 und 2026 konvergieren, ist hybrid: Kunden der Standardstufe teilen sich gepoolte Infrastruktur, während Enterprise-Konten mit Compliance- oder schweren Lasten ein isoliertes Schema oder eine isolierte Datenbank erhalten. Das spiegelt deine Preisstufen direkt wider. Eine harte Warnung: Datenbank pro Mandant skaliert auf Postgres oder MySQL nicht auf Zehntausende von Mandanten. Du bekommst Katalogaufblähung, DDL-Engpässe und eine Cloud-Rechnung, die das Geschäft bedrohen kann. Wenn du erwartest, Kunden zwischen Stufen zu verschieben, baue die Migrationswerkzeuge früh, denn sie nachträglich einzubauen ist schmerzhaft.

Erzwinge Mandantenisolation in der Datenbank, nicht nur in der App

In einem gepoolten Modell steht zwischen den Daten von Mandant A und Mandant B nur eine WHERE tenant_id = ?-Klausel, und sich darauf zu verlassen, dass jeder Entwickler sie bei jeder Abfrage erinnert, ist ein Datenleck, das nur darauf wartet, einzutreten. Der Standard von 2025 ist, diese Durchsetzung mit der Row-Level Security (RLS) von PostgreSQL in die Engine hinunterzudrücken. Sobald die Sitzung den Mandantenkontext setzt, filtert die Datenbank jede Abfrage automatisch, durch Konstruktion statt durch Gewohnheit. Der Mandantenkontext reist typischerweise im Sitzungstoken als JWT-Claim mit, und deine Autorisierungsschicht sollte bei jeder Anfrage erneut prüfen, dass der Mandant des Tokens zum authentifizierten Benutzer passt, nicht nur beim Login. Ein Detail, das Teams übersehen: Die Isolation muss sich über den gesamten Stack erstrecken, nicht nur über die primäre Datenbank. Auch dein Cache, deine Nachrichtenwarteschlangen, dein Dateispeicher und deine Suchindizes müssen mandantenbezogen abgegrenzt sein. Ein gängiges Muster für die Suche ist ein Namensschema mit einem Index pro Mandant, damit Einstellungen und Lebenszyklusregeln getrennt bleiben.

Optimiere die Datenbank, bevor du sie skalierst

Datenbankskalierung ist der Ort, an dem die richtige Reihenfolge die größte Rendite bringt, denn die Datenbank ist meist der begrenzende Faktor, während App-Server sich leicht horizontal herausskalieren lassen. Ineffiziente Abfragen sind für einen großen Teil der realen Engpässe verantwortlich, oft für die Mehrheit. Beginne damit, langsame Abfragen zu profilieren und die Indizes hinzuzufügen, die deine häufigsten Zugriffsmuster wirklich brauchen. Eine ordentliche Indizierung kann Abfragezeiten drastisch senken. Spüre N+1-Abfragemuster in deinem ORM auf, bei denen das Auflisten von Einträgen eine zusätzliche Abfrage pro Zeile auslöst, bei 10 Zeilen in Ordnung und bei 10.000 ruinös. Nutze Connection Pooling, damit du nicht zig Millisekunden Aufbaukosten pro Anfrage zahlst. Erst wenn die Abfragen sauber sind, greifst du zu strukturellen Änderungen: das Partitionieren einer großen Tabelle in Teile, damit die Engine irrelevante wegschneiden kann, Read Replicas für leselastige Workloads und schließlich Sharding über Server, wenn eine einzelne Instanz die Daten wirklich nicht halten kann. Die Reihenfolge ist wichtig, weil jeder Schritt betriebliche Komplexität hinzufügt, und du willst diese Komplexität nur dort ausgeben, wo der Optimierung schon der Spielraum ausgegangen ist.

Caching: der wirkungsvollste Hebel, den du hast

Caching ist die wirksamste und am wenigsten störende Änderung, die du an der Datenbank-Performance vornehmen kannst. Eine gut konfigurierte Redis- oder Memcached-Schicht kann eine große Mehrheit der Lesezugriffe aus dem Speicher bedienen, oft 70 bis 90 Prozent, sodass sie die Datenbank nie berühren. Der gängige Ansatz ist Cache-Aside (Lazy Loading): Die App prüft zuerst den Cache und liest bei einem Fehltreffer aus der Datenbank und füllt den Cache. Kurzlebige Caches funktionieren gut für Dashboard-Aggregate, die ein paar Sekunden Veralterung vertragen. Aber Caching ist ein Kompromiss, kein kostenloses Tempo. Veraltete Daten, wenn die Invalidierung fehlschlägt, und Lastspitzen, wenn ein Cache ausfällt und der Traffic die Datenbank überrennt, sind echte Fehlermodi. Plane für sie: sinnvolle TTLs, bewusste Invalidierung und anständiges Verhalten, wenn der Cache kalt ist. Read Replicas passen für leselastiges SaaS natürlich zu Caching, mit der einen Einschränkung der Replikationsverzögerung. Wenn ein Benutzer sein Profil aktualisiert und es sofort von einem Replikat zurückliest, sieht er womöglich den alten Wert, also leite Read-after-Write-Pfade an die Primärdatenbank.

Lastverteilung, zustandslose Dienste und Autoscaling

Horizontale Skalierung funktioniert nur, wenn deine Anwendungsserver zustandslos sind. Wenn kein Server Sitzungszustand im Speicher hält, kann jeder Server jede Anfrage bearbeiten, und ein Load Balancer kann den Traffic frei verteilen, während er Ausfälle mit Health Checks kaschiert. Schiebe Sitzung und geteilten Zustand in Redis oder die Datenbank. Mit zustandslosen Diensten passt Autoscaling die Kapazität an die Last an. Target-Tracking (etwa die CPU nahe 70 Prozent halten) und geplante Skalierung für bekannte Spitzen decken die meisten Bedürfnisse ab, mit prädiktiver und warteschlangenbasierter Skalierung für anspruchsvollere Workloads. Auf Kubernetes entspricht das dem Horizontal Pod Autoscaler für die Pod-Anzahl, dem Vertical Pod Autoscaler für Ressourcen pro Pod und dem Cluster Autoscaler für Knoten. Füge Scale-in- und Scale-out-Cooldowns in der Größenordnung mehrerer Minuten hinzu, damit das System nicht oszilliert. Die zentrale Disziplin: Wenn ein SLO reißt und der Dienst noch Reserven hat, skaliere Rechenleistung, aber wenn die Datenbank der Engpass ist, greife zuerst zu Partitionierung, Replikaten und Caching. App-Server auf ein Datenbankproblem zu werfen, verschiebt nur die Warteschlange.

Triff Skalierungsentscheidungen aus dem Monitoring, nicht aus dem Bauch

Du kannst nicht steuern, was du nicht messen kannst, und jeder Hebel oben hängt von echter Telemetrie ab. Definiere als SLOs, wie gut aussieht: ein p95-Latenzziel, eine Fehlerraten-Obergrenze, die CPU in einem gesunden Band. Verfolge die stützenden Signale, Anfragelatenz und Durchsatz, Datenbank-Abfrageleistung, Warteschlangentiefe, CPU- und Speichersättigung, mit Dashboards in etwas wie Prometheus und Grafana. Borge dir dann die Error-Budget-Idee von SRE: Dein Budget ist 100 Prozent minus deinem SLO. Ein Verfügbarkeitsziel von 99,9 Prozent pro Monat lässt rund 43 Minuten erlaubte Ausfallzeit. Wenn das Budget gesund ist, liefere Funktionen mit Zuversicht aus. Wenn es abbrennt, verlangsame riskante Änderungen und finde, was es auffrisst. Das fasst Zuverlässigkeit als eine Ressource neu, die Produkt und Engineering teilen, statt als einen Streit. Es sagt dir auch, wann zu skalieren ist: anhaltender SLO-Druck unter echter Last ist das Signal, Kapazität hinzuzufügen, und ein ruhiges System mit Budget im Überfluss ist das Signal, dass du Raum hast, weiterzugehen.

Bereit zum Launch?

Sagen Sie uns, wo Sie feststecken. Wir prüfen es und senden Ihnen innerhalb eines Werktags eine konkrete Empfehlung.

Häufig gestellte Fragen

Wann sollte ich anfangen, meine SaaS-Anwendung zu skalieren?

Skaliere, wenn das Monitoring anhaltenden Druck auf deine SLOs unter echter Last zeigt: die p95-Latenz kriecht nach oben, die Fehlerraten steigen in den Spitzen, oder Warteschlangen stauen sich. Vor diesem Punkt investiere in Performance-Optimierung, schnellere Abfragen, Indizes und Caching, da das günstiger ist und echten Spielraum verschafft. Ein klares Signal, dass die Optimierung erschöpft ist, sind 5xx-Fehler in den Stoßzeiten, was bedeutet, dass es Zeit ist, echte Kapazität hinzuzufügen, statt nach mehr Tempo zu quetschen.

Welches Mandantenmodell sollte ich wählen?

Die meisten Teams sollten mit einem gepoolten Modell mit geteiltem Schema beginnen, geschützt durch Row-Level Security, weil es am kosteneffizientesten ist und Funktionen an alle auf einmal ausliefert. Wenn du wächst, wechsle zu einem Hybridmodell: Halte Standardkunden gepoolt und gib Enterprise-Konten mit Compliance- oder schweren Lastanforderungen ein isoliertes Schema oder eine dedizierte Datenbank. Vermeide Datenbank pro Mandant als Standard, da sie auf Postgres oder MySQL nicht über Tausende von Mandanten hinaus skaliert und deine Infrastrukturrechnung aufbläht.

Sollte ich zuerst Caching oder Read Replicas hinzufügen?

Füge zuerst Caching hinzu. Eine Redis- oder Memcached-Schicht ist die am wenigsten störende Änderung und kann die große Mehrheit der Lesezugriffe aus dem Speicher bedienen, was der Datenbank sofort Last abnimmt. Read Replicas sind der nächste Schritt für leselastige Workloads, aber sie bringen Replikationsverzögerung mit sich, also leite Read-after-Write-Pfade an die Primärdatenbank. Mach beides erst, nachdem du langsame Abfragen und fehlende Indizes profiliert und behoben hast, denn langsame Abfragen zu cachen verbirgt nur das Problem.

Warum ist die Datenbank meist der Engpass beim Skalieren?

Anwendungsserver skalieren fast trivial horizontal heraus, weil sie zustandslos sein können, also fügst du einfach mehr davon hinter einem Load Balancer hinzu. Die Datenbank hält Zustand, koordiniert Schreibvorgänge und ist weitaus schwerer zu teilen, weshalb sie zum Engpass wird. Die Reihenfolge der Behebung ist zuerst Optimierung (Indizes, Abfrage-Tuning, das Ausmerzen von N+1-Mustern), dann Caching, dann Read Replicas, dann Partitionierung und erst Sharding oder verteiltes SQL, wenn eine einzelne Instanz wirklich nicht mehr mitkommt.

Welche Kennzahlen sollte ich verfolgen, um gut zu skalieren?

Verfolge die Latenz als Perzentile (p50, p95, p99) statt als Durchschnitte, dazu den Durchsatz in Anfragen pro Sekunde, die Fehlerrate, die Datenbank-Abfrageleistung, die Warteschlangentiefe sowie die CPU- und Speichersättigung. Verwandle die wichtigen in SLOs mit einem Error-Budget, deiner zulässigen Unzuverlässigkeit, damit Skalierungs- und Deployment-Entscheidungen datengetrieben werden. Hier sind hochauflösende Echtzeitdaten wichtig, denn Lücken im Monitoring führen zu ungenauen Budgets und verpassten Alarmen.

Müssen meine Dienste zustandslos sein, um horizontal zu skalieren?

Im Grunde ja. Wenn ein Server Sitzungs- oder anderen Zustand in seinem eigenen Speicher hält, werden Anfragen an bestimmte Server gebunden, und ein Load Balancer kann den Traffic nicht frei verteilen oder von einem ausgefallenen Knoten erholen. Verschiebe Sitzungsdaten und geteilten Zustand in einen Cache wie Redis oder die Datenbank, damit jeder Server jede Anfrage bearbeiten kann. Zustandsloses Design ist die Voraussetzung, die es Autoscaling und Lastverteilung erlaubt, ihre Arbeit zu tun.

Wöchentliche Impulse für den Betrieb

Schließen Sie sich Betreibern von Dienstleistungsunternehmen an, die jede Woche einen umsetzbaren Impuls zu Betrieb, Automatisierung und Wachstum erhalten.

Wir prüfen kurz, ob Sie ein Mensch sind. Gleich können Sie senden.

Kein Spam. Jederzeit abbestellbar.

Sie sind angemeldet! Die nächste Ausgabe kommt in Ihr Postfach.