Entwicklung22. August 20248 Min. Lesezeit#nextjs#architecture#performance

Resiliente Systeme mit Next.js bauen

Best Practices für Hochverfügbarkeit und Performance in modernen Webanwendungen.

TL;DR5
  1. Architektur vor Tooling: Resilienz ist eine Design-Eigenschaft
  2. ISR mit stale-while-revalidate hält Seiten bei Backend-Ausfällen am Leben
  3. Retries brauchen Backoff und Jitter — Circuit Breaker stoppen Kaskadenfehler
  4. Error Boundaries isolieren Fehler auf das betroffene Widget, nicht die Seite
  5. Fallback-UI und Offline-Toleranz sind First-Class-Features, keine Patches
Resiliente Systeme mit Next.js bauen

Architektur zuerst

Next.js dient oft als Rückgrat moderner Webanwendungen. Resilienz erfordert eine Mischung aus guten Architekturentscheidungen und dem richtigen Tooling.

Mit Server Components und sauberen Error Boundaries lassen sich extrem resiliente Webanwendungen bauen, die graceful degradieren, statt komplett abzustürzen.

Static Generation vs SSR

Im Zweifel immer Incremental Static Regeneration (ISR) wählen. Das garantiert, dass Nutzer selbst bei einem temporären Ausfall der Backend-APIs die zuletzt erfolgreich gebaute Version der Seite sehen.

Der Tradeoff ist real: ISR liefert Resilienz auf Kosten der Frische. SSR liefert Frische auf Kosten einer harten Abhängigkeit vom Backend.

// app/blog/[slug]/page.tsx
export const revalidate = 300; // 5 Minuten

export default async function Post({ params }) {
  const post = await fetchPost(params.slug); // gecacht + revalidiert
  return <Article post={post} />;
}

Als meine Origin-API letztes Jahr während eines Cloudflare-Incidents 40 Minuten lang ausfiel, lieferten alle ISR-Seiten auf y7.hk weiterhin stale-aber-valides HTML. Die SSR-Seiten derselben Site warfen 500er. Dieses Experiment kostete mich 4 % des monatlichen Traffics — und hat meine Render-Strategie nachhaltig verändert.

Faustregel: ISR für alles, was 5–60 Minuten alt sein darf (Blogposts, Produktseiten, Marketing). SSR nur, wenn Staleness das Produkt bricht (Live-Dashboards, Auth-State, Echtzeitdaten).

Error Boundaries sind Schotten

Ohne Boundaries reißt ein einziges fehlschlagendes Widget die ganze Seite mit. Mit Boundaries schlägt jede Sektion unabhängig fehl.

// app/components/Section.tsx
'use client';
import { Component, ReactNode } from 'react';

export class Section extends Component<
  { children: ReactNode; fallback?: ReactNode },
  { hasError: boolean }
> {
  state = { hasError: false };

  static getDerivedStateFromError() {
    return { hasError: true };
  }

  render() {
    if (this.state.hasError) {
      return this.props.fallback ?? <div className="opacity-50">Bereich nicht verfügbar</div>;
    }
    return this.props.children;
  }
}

Jede unabhängige Einheit — Sidebar-Widgets, Kommentarbereiche, Analytics-Dashboards — gehört in eine eigene Boundary. Der Nutzer sieht eine graue Box, wo das Widget war, keinen leeren Screen.

Ich habe das auf die harte Tour gelernt, als ein einziger RPC-Timeout auf einem Web3-Dashboard die gesamte Portfolio-Ansicht abstürzen ließ. Eine Boundary um den Price-Ticker hätte die Session gerettet.

Retries brauchen Backoff

Blinde Retries verstärken Fehler. Exponentieller Backoff mit Jitter verteilt die Last und gibt dem Upstream Zeit zur Erholung.

async function fetchWithRetry<T>(
  fn: () => Promise<T>,
  attempts = 3,
  baseDelay = 300
): Promise<T> {
  for (let i = 0; i < attempts; i++) {
    try {
      return await fn();
    } catch (err) {
      if (i === attempts - 1) throw err;
      const jitter = Math.random() * baseDelay;
      await new Promise(r => setTimeout(r, baseDelay * 2 ** i + jitter));
    }
  }
  throw new Error('unreachable');
}

Zwei Regeln, an die ich mich halte:

  1. Niemals 4xx retries. Aus einer 404 wird durch Retry keine 200.
  2. Gesamtwartezeit begrenzen. Wenn der Nutzer 8+ Sekunden auf einen Spinner starrt, Fallback-UI zeigen und weiterarbeiten lassen.

Circuit Breaker stoppen Kaskadenfehler

Retries lösen transiente Fehler. Circuit Breaker lösen persistente. Wenn das Backend seit 30 Sekunden ausfällt, hör auf es zu hämmern — öffne den Circuit und liefere sofort degradierte Antworten.

class Breaker {
  private failures = 0;
  private openUntil = 0;
  constructor(private threshold = 5, private cooldown = 30_000) {}

  async call<T>(fn: () => Promise<T>): Promise<T> {
    if (Date.now() < this.openUntil) throw new Error('Circuit open');
    try {
      const result = await fn();
      this.failures = 0;
      return result;
    } catch (e) {
      if (++this.failures >= this.threshold) {
        this.openUntil = Date.now() + this.cooldown;
      }
      throw e;
    }
  }
}

Ohne Breaker verwandelt sich ein langsamer Upstream in eine Flotte hängender Node-Prozesse. Mit Breaker bekommst du schnelle Fehler und ein System, das sofort mit dem Upstream zurückkommt.

Edge-Caching mit stale-while-revalidate

Der Cache-Control-Header ist die billigste Resilienz-Schicht. stale-while-revalidate lässt den Edge die letzte Cache-Kopie ausliefern, während im Hintergrund eine frische geholt wird.

Cache-Control: public, s-maxage=60, stale-while-revalidate=600

Das ist der Unterschied zwischen „die API ist down, also ist die Site down” und „die API ist down, also sehen manche Nutzer 10 Minuten alte Daten”.

Fallback-UI als Feature

Fallbacks sind nicht, was du zeigst, wenn etwas kaputt geht — sie sind Teil des Designs. Jede asynchrone Sektion hat drei Zustände:

  • Laden: Skeleton, das dem finalen Layout entspricht (kein Layout-Shift).
  • Erfolg: der echte Content.
  • Fehler: eine degradierte Version, mit der der Nutzer trotzdem arbeiten kann.

Wenn dein Pricing-Widget ausfällt, zeig keinen roten Fehler — zeig die zuletzt gecachten Preise mit einem „vor 12 Minuten aktualisiert”-Badge. Wenn das Kommentarsystem ausfällt, zeig den Read-Only-Thread und blende die Eingabe aus.

Offline-Toleranz

Service Worker sind nicht nur für PWAs. Ein minimaler SW, der die App-Shell und die letzten 5 besuchten Seiten cached, gibt dir echte Offline-Toleranz auf wackeligem Hotel-WLAN und auf 10 000 Metern — was bei mir einen nicht-trivialen Anteil meines Browsings ausmacht.

// sw.ts — cache-first für statisches, network-first für Seiten
self.addEventListener('fetch', (e) => {
  const url = new URL(e.request.url);
  if (url.pathname.startsWith('/_next/static/')) {
    e.respondWith(caches.match(e.request).then(r => r ?? fetch(e.request)));
  }
});

Echte Ausfälle, die ich erlebt habe

  • Cloudflare-Edge-KV-Ausfall: Jede Seite, die von KV abhing, warf 500. ISR-Seiten überlebten.
  • Upstream-CMS hat mich während eines Traffic-Spikes gerate-limitet. Ich hatte keinen Breaker; Next.js hämmerte auf das CMS bis zum harten IP-Ban. Jetzt läuft jeder externe Call durch einen Breaker mit 30 s Cooldown.
  • Ein einzelnes <PriceTicker>-Component hat das ganze Dashboard gecrasht, als die WebSocket-Verbindung abriss. Nach der Boundary blieb der Rest der UI live, während der Ticker still reconnectete.

Resilienz-Checkliste

  • ISR/SSG für Content, der 5+ Minuten Staleness toleriert
  • stale-while-revalidate auf jeder cachebaren Route
  • Error Boundary um jedes unabhängige Widget
  • Exponentieller Backoff + Jitter bei Retries; niemals 4xx retries
  • Circuit Breaker bei jedem externen Service-Call
  • Skeleton + Fallback + Error-State für jedes async UI
  • Service Worker, der die App-Shell cached
  • Dokumentierter Kill-Switch für nicht-kritische Features (Analytics, Empfehlungen)

Der Punkt

Resilienz ist kein Feature, das man am Ende anschraubt. Sie ist die Architektur selbst. Jede Schicht — Rendering, Caching, Fetching, UI — bekommt ihren Failure-Mode von Anfang an mitdesignt. Wer das früh einbaut, erlebt, dass Incidents, die Ausfälle gewesen wären, zu stillen Degradationen werden, die niemand bemerkt.

Animiertes Avatar-Video
Yakushev Hermann
Visionärer Gründer · Senior Agentic AI Architect · Networking

Mehr aus dem Blog

Anatomie eines modernen Engineering-Artikels auf y7.hk

Ein Stresstest für die y7-Lese-Engine: Callouts, Diff-Blöcke, KaTeX-Formeln, ein rundes Avatar-Video, Figure-Galerien, Spoiler und ein Font-Umschalter.

15. Okt. 2026 · 5 Min. Lesezeit

Leben zwischen Zeitzonen

Was 67 Länder und vier Lebensmittelpunkte über Deep Work, Jetlag und den Bau von Produkten lehren, um die niemand gebeten hat.

18. Juli 2026 · 6 Min. Lesezeit