Der kritische Pfad in Software: finden, abbilden, absichern

Kurz gesagt

Niveau: Fortgeschritten

Der kritische Pfad ist die kurze Kette von Schritten, die funktionieren muss, damit das Unternehmen Geld verdient oder seine gesetzlichen Pflichten erfüllt: Warenkorb, Kasse, Zahlung, Bestellung, Bestätigung, Rechnung, Datenauskunft.

  • Finde ihn, indem du dem Geld, dem Gesetz und der Kundschaft folgst.
  • Bewerte jeden Schritt als Wahrscheinlichkeit mal Auswirkung, und lass jede gesetzliche Pflicht auf dem Pfad, egal wie ihr Wert ist.
  • Bild ihn von oben nach unten mit jedem Fehlerzweig ab und schreib ihn ins Repository.
  • Sichere ihn sechsfach ab: End to End Tests mit dem Tag @critical, Vertragstests an den Grenzen, ein Release Gate, das sie zuerst laufen lässt, eine Freigabe, die den verifizierten Pfad einfriert, ein Smoke Test nach jedem Deploy und ein Alarm, wenn Bestellungen ausbleiben.

Eine kaputte Blogseite ist peinlich. Ein kaputter Checkout ist ein Shop, der offen hat, gut besucht ist und keinen Cent einnimmt. Dieses Kapitel zeigt, wie du die wenigen Schritte findest, die deine Software nie falsch machen darf, und wie du sie so absicherst, dass kein Release sie still bricht, durchgespielt an einem erfundenen Teeshop in Hamburg.

Der Teil deiner Software, der die Rechnungen bezahlt

Eine kaputte Blogseite ist peinlich. Ein kaputter Checkout ist ein Shop, der offen hat, gut besucht ist und keinen Cent einnimmt. Beides sind Fehler. Nur einer davon kostet dich einen Tagesumsatz, bevor es überhaupt jemand merkt.

Die Frage dieses Artikels ist also schlicht: Welcher Teil meiner Software darf nie kaputtgehen, und wie stelle ich sicher, dass er es nicht tut? Die Antwort hat einen Namen, den kritischen Pfad, und drei Aufgaben. Du findest ihn, du bildest ihn ab, und du sicherst ihn ab.

Vorab ein Hinweis, weil derselbe Begriff im Projektmanagement etwas anderes bedeutet. Dort ist der kritische Pfad die längste Kette von Aufgaben, die bestimmt, wann ein Projekt frühestens fertig ist. Über diese Bedeutung habe ich im Artikel zu Time to Market geschrieben. Hier geht es um etwas anderes: eine Kette von Schritten in der laufenden Software, nicht eine Kette von Aufgaben in einem Plan.

Dieses Kapitel baut auf dem vorigen der Serie auf, Unit, Integrations und End to End Tests. Ist dir der Begriff "End to End Test" neu, fang dort an. Sonst lies einfach weiter.

Was der kritische Pfad ist

Der kritische Pfad ist die Kette von Schritten, die funktionieren muss, damit das Unternehmen Geld verdient oder seine gesetzlichen Pflichten erfüllt. Bricht ein Glied dieser Kette, verdient das Unternehmen nichts mehr oder verstößt gegen das Gesetz. Alles andere in der Software zählt auch, darf aber einen Nachmittag lang kaputt sein, ohne echten Schaden.

Bei einem Onlineshop sieht die Kette meist so aus: Eine Kundin registriert sich oder bestellt als Gast, meldet sich an, falls sie ein Konto hat, legt etwas in den Warenkorb, geht zur Kasse, bezahlt, bekommt eine Bestellbestätigung und später eine Rechnung. Daneben läuft eine rechtliche Kette, die man leicht vergisst: Fragt jemand nach einer Kopie seiner Daten oder will sie gelöscht haben, muss die Software das können.

Was nicht auf der Liste steht: der Blog, die Seite "Über uns", Produktbewertungen, die Anmeldung zum Newsletter. Alles nützlich. Nichts davon stoppt das Geld oder bricht das Gesetz, wenn es eine Stunde lang ausfällt.

Ich lege den kritischen Pfad jedes Produkts fest, das ich baue, weil sich alles Weitere beim Testen und Ausliefern daraus ergibt.

Beispiel: der kritische Pfad eines Teeshops in einfachen Worten

Teekontor Hansen ist ein Onlineshop für Tee in Hamburg (für diese Serie erfunden, unter teekontorhansen.example). Er verkauft losen Tee in 100 g Beuteln und monatliche Teeabos, nimmt Kartenzahlungen über einen Zahlungsanbieter an, bietet Rabattcodes, führt einen Lagerbestand und verschickt Bestellmails. Die Entwicklerin heißt Jana, der Inhaber Henrik.

Auf die Frage "Was darf nie kaputtgehen?" schreiben Henrik und Jana diese Liste ans Whiteboard:

  1. Eine Kundin findet einen Tee und öffnet die Produktseite.
  2. Sie legt ihn in den Warenkorb und ändert die Menge.
  3. Sie geht zur Kasse, mit Adresse, Versandart und, falls vorhanden, einem Rabattcode.
  4. Der Zahlungsanbieter genehmigt oder lehnt die Karte ab, und der Shop zeigt das richtige Ergebnis.
  5. Eine genehmigte Zahlung erzeugt genau eine Bestellung und senkt den Bestand genau einmal.
  6. Die Kundin bekommt eine Bestätigungsmail.
  7. Die Bestellung bekommt eine Rechnung mit dem richtigen Umsatzsteuersatz für jeden Artikel.
  8. Verlangt jemand Auskunft über seine Daten oder deren Löschung, kann Jana sie exportieren oder löschen.

Die Schritte eins bis sieben sind die Geldkette. Schritt acht ist die rechtliche Kette. Abos verlängern sich jeden Monat über die Schritte vier bis sieben, sie laufen also über denselben Pfad. Das ist der ganze kritische Pfad von Teekontor Hansen, acht Zeilen lang.

So findest du ihn: folge dem Geld, dem Gesetz und der Kundschaft

Eine Liste am Whiteboard ist ein guter Anfang, hängt aber davon ab, wer im Raum ist. Drei Fragen machen die Suche systematisch, und jede findet etwas, das die anderen übersehen.

Folge dem Geld

Verfolge einen Euro von der Karte der Kundin bis auf dein Bankkonto. Jede Seite, jeder Hintergrundjob und jeder externe Dienst, durch den dieser Euro läuft, gehört zum kritischen Pfad. So findest du die Teile, die niemand sieht: den Webhook (eine Nachricht, die der Zahlungsanbieter an deinen Server schickt, um zu sagen "diese Zahlung ist durch"), den Job, der die Bestellung als bezahlt markiert, die Anpassung des Bestands.

Folge dem Gesetz

Schreib auf, was deine Software von Gesetzes wegen können muss, mit Frist. Zwei Dinge tauchen fast überall auf. Rechnungen brauchen die richtigen Angaben. Und nach der Datenschutz Grundverordnung (DSGVO) musst du auf einen Antrag auf Auskunft oder Löschung grundsätzlich innerhalb eines Monats reagieren1. Kann deine Software diese Auskunft nicht erstellen, merkst du das an dem Tag, an dem jemand fragt, und die Frist läuft schon.

Folge der Kundschaft

Setz dich neben eine echte Kundin oder lies deine Supportmails, und notier die Momente, in denen ein Fehler sie vertreiben oder verärgern würde. So findest du, was die ersten beiden Fragen übersehen: eine Anmeldung, die Leute aussperrt, eine Mail zum Zurücksetzen des Passworts, die nie ankommt, einen Rabattcode, der stillschweigend nichts tut.

Beispiel: drei Fragen, drei neue Funde

Als Jana Teekontor Hansen durch die drei Fragen schickt, ergänzt jede etwas an der Liste.

Folge dem Geld fördert den Webhook der Zahlung zutage. Die Kasse kann "Danke" anzeigen, während der Webhook im Hintergrund scheitert. Dann wird die Bestellung nie als bezahlt markiert und nie verschickt. Der Webhook kommt zu Schritt fünf.

Folge dem Gesetz fördert die Datenauskunft zutage. Niemand hatte den Export je getestet. Jana probiert ihn an einer Kopie der Datenbank aus und stellt fest, dass die Abohistorie fehlt. Daraus wird Schritt acht, mit Test.

Folge der Kundschaft fördert die Mail zum Zurücksetzen des Passworts zutage. Henriks Supportpostfach zeigt: Wer sein Passwort vergisst und die Mail nie bekommt, kündigt das Abo, statt nachzufragen. Das Zurücksetzen kommt neben die Anmeldung auf den Pfad.

Zehn Minuten pro Frage, und die Liste ist vollständiger, als sie eine Person allein je gemacht hätte.

Bewerte das Risiko, damit die Tests dort landen, wo der Schaden liegt

Nicht jeder Schritt auf dem Pfad braucht gleich viel Test. Die Testbranche hat dafür eine Standardmethode, das risikobasierte Testen. Das International Software Testing Qualifications Board (ISTQB) beschreibt ein Risiko über zwei Faktoren: die Wahrscheinlichkeit, dass etwas schiefgeht, und die Auswirkung, wenn es passiert. Zusammen ergeben sie die Risikostufe, und im quantitativen Ansatz ist das schlicht das eine mal das andere2.

R=L×IR = L \times I

Dabei ist RR der Risikowert eines Schritts, LL die Wahrscheinlichkeit (Likelihood), dass eine Änderung diesen Schritt bricht, auf einer Skala von 1 (selten) bis 5 (bei fast jedem Release, der ihn berührt), und II die Auswirkung (Impact), von 1 (kosmetisch) bis 5 (Geld verloren oder gesetzliche Pflicht verpasst). Die Idee ist nah am Erwartungswert, der Chance eines Ereignisses mal seiner Größe. Die Grundlagen: Erwartungswert erklären das von Grund auf.

Die Zahlen sind Einschätzung, keine Messung. Ihre Aufgabe ist, dass zwei Menschen über das Richtige streiten ("Ist der Rabattcode wirklich eine 4?") statt über das Falsche ("Testen wir das überhaupt?").

Dann leg eine Regel fest: Jeder Schritt mit einem Wert von 12 oder mehr gehört auf den kritischen Pfad, und ebenso jeder Schritt mit einer gesetzlichen Pflicht, egal wie hoch sein Wert ist. Die zweite Hälfte der Regel ist wichtig. Gesetzliche Pflichten kommen oft selten und leise daher, ihre Wahrscheinlichkeit wirkt gering, und ein niedriger Wert würde sie verstecken.

Beispiel: der Teeshop, Schritt für Schritt bewertet

Jana und Henrik bewerten jeden Schritt gemeinsam. Die Zahlen sind für dieses Beispiel erfunden.

SchrittWahrscheinlichkeit LLAuswirkung IIWert RRKritisch?
Rabattcode an der Kasse4416Ja
Kartenzahlung und Webhook3515Ja
Bestellung gespeichert, Bestand einmal gesenkt3515Ja
Anmeldung und Passwort zurücksetzen3412Ja
Bestätigungsmail339Nein, nach Wert
Rechnung mit Umsatzsteuer248Ja, gesetzliche Pflicht
Datenauskunft und Löschung248Ja, gesetzliche Pflicht
In den Warenkorb legen248Nein, nach Wert
Newsletter Anmeldung224Nein
Produktbewertungen313Nein

Nimm die oberste Zeile Schritt für Schritt. Die Rabattlogik ändert sich oft, weil Henrik fast jeden Monat eine neue Aktion fährt, also schätzt Jana die Wahrscheinlichkeit auf L=4L = 4. Ein kaputter Code verschenkt entweder Tee oder lässt Leute den Warenkorb stehen, also ist die Auswirkung I=4I = 4. Der Wert ist R=4×4=16R = 4 \times 4 = 16, über der Schwelle von 12, also kritisch.

Jetzt zwei Zeilen, bei denen die Regel nachhilft. Die Rechnung kommt nur auf 2×4=82 \times 4 = 8, ist aber eine gesetzliche Pflicht und kommt deshalb trotzdem auf den Pfad. Bestätigungsmail und Warenkorb liegen beide unter 12. Henrik und Jana besprechen sie und nehmen sie trotzdem auf, weil eine Kundin ohne Mail oder ohne funktionierenden Warenkorb genauso sicher verloren ist. Die Regel ist der Startpunkt für dieses Gespräch, kein Ersatz dafür.

Balkendiagramm mit erfundenen Risikowerten, Wahrscheinlichkeit mal Auswirkung, für zehn Schritte eines Beispiel Teeshops. Rabattcode 16, Kartenzahlung 15, Bestellung und Bestand 15, Anmeldung 12, Bestätigungsmail 9, Rechnung 8, Datenauskunft 8, Warenkorb 8, Newsletter 4, Bewertungen 3. Die Schwelle für den kritischen Pfad liegt bei 12. Zum Vergrößern antippen: Vollbild, frei verschiebbar

Bild ihn als Diagramm ab

Eine Liste sagt dir, welche Schritte zählen. Eine Karte zeigt, wie sie zusammenhängen, und genauso wichtig, wo jeder davon scheitern kann und was dann passieren soll. Beim Zeichnen der Fehlerzweige merken die meisten, dass nie jemand entschieden hat, was bei einer abgelehnten Karte passiert oder wenn der Mailversand ausfällt.

Zeichne von oben nach unten, ein Kasten pro Schritt, eine Raute für jede Entscheidung der Software und ein eigener Kasten für jeden Fehlerfall. Dann markier den Weg, den eine normale, erfolgreiche Bestellung nimmt. Dieser Weg ist der kritische Pfad. Die Abzweigungen sind die Stellen, an denen ein Test beweisen muss, dass der Shop sicher scheitert.

Beispiel: die Kasse des Teeshops als Karte

Jana zeichnet die Geldkette mit jeder Stelle, an der sie reißen kann. Der hervorgehobene Weg ist der kritische Pfad, den jedes Release intakt lassen muss.

Zum Vergrößern antippen: Vollbild, frei verschiebbar

Drei Dinge auf dieser Karte waren vorher nirgends festgehalten. Ein abgelehnter Rabattcode darf den Warenkorb nicht leeren. Eine abgelehnte Karte muss die Kundin dort lassen, wo sie war, mit einer Meldung, die sie versteht. Und eine gescheiterte Mail darf die Rechnung nicht blockieren, sie kommt in eine Warteschlange und alarmiert einen Menschen. Jeder dieser drei Sätze wird ein Test.

Schreib ihn dort auf, wo der Code liegt

Ein kritischer Pfad, der nur am Whiteboard steht, ist beim nächsten Release vergessen. Leg ihn als einfache Textdatei ins Repository, direkt neben den Code. Dann ist er mit dem Code versioniert, und alle, die am Projekt arbeiten (auch jeder KI Assistent), können ihn lesen. Und verweise mit jedem Test, der ihn absichert, auf diese Datei.

Beispiel: die Datei mit dem kritischen Pfad

Jana legt eine Datei docs/critical_path.md im Repository an:

# Teekontor Hansen: kritischer Pfad

Verifiziert am 3. November 2026, freigegeben von Henrik (Inhaber)

1. Produktseite öffnet sich für jeden Tee auf Lager
2. Warenkorb: hinzufügen, Menge ändern, entfernen
3. Kasse: Adresse, Versandart, Rabattcode
4. Kartenzahlung genehmigt oder klar abgelehnt, Warenkorb bleibt bei Ablehnung
5. Webhook markiert die Bestellung als bezahlt: eine Bestellung, Bestand einmal gesenkt
6. Bestätigungsmail verschickt oder mit Alarm zur Wiederholung eingereiht
7. Rechnung mit dem richtigen Umsatzsteuersatz je Artikel
8. Datenauskunft und Löschung auf Antrag
Außerdem: Anmeldung und Passwort zurücksetzen

Abgesichert durch: jedes Szenario mit dem Tag @critical in features/critical/
Änderungsregel: jede Änderung an diesen Schritten braucht Henriks Freigabe

Lies sie Zeile für Zeile. Der Titel nennt den Shop. Die Zeile "Verifiziert" hält fest, wann der Pfad zuletzt geprüft wurde und wer ihn freigegeben hat. Die nummerierten Zeilen sind der Pfad selbst, in Worten, die Henrik ohne Programmierkenntnisse versteht. Die letzten beiden Zeilen sind die Brücke zum Code: wo die Tests liegen und wer eine Änderung freigeben muss. Diese zwei Zeilen machen aus einem Dokument eine Absicherung.

Absicherung eins: ein End to End Test für jeden Schritt

Ein End to End Test bedient die echte Anwendung so, wie es eine Kundin tun würde: Er öffnet Seiten, füllt Formulare aus, drückt Buttons und prüft, was erscheint. Das ist die langsamste Testart, deshalb hat das vorige Kapitel für wenige davon plädiert. Der kritische Pfad ist genau der Ort, an den diese wenigen gehören.

Schreib jeden Schritt als verhaltensgetriebenes Szenario in Gherkin, dem Klartextformat, das Cucumber liest, und versieh es mit dem Tag @critical. Ein Tag ist ein Etikett an einem Test, mit dem du eine ausgewählte Gruppe allein laufen lassen kannst3. (Der Artikel über Cucumber erklärt das Werkzeug ausführlich. Hier brauchen wir nur den Tag.)

Beispiel: die Zahlung als kritisches Szenario

Jana schreibt dieses Szenario in features/critical/checkout.feature. Cucumber versteht Gherkin auch auf Deutsch, die erste Zeile schaltet das ein:

# language: de
@critical
Funktionalität: Tee bezahlen

  Szenario: Ein Gast zahlt mit Karte und bekommt genau eine Bestellung
    Angenommen "Assam Breakfast" kostet 6,50 € und 12 Beutel sind auf Lager
    Wenn ein Gast einen Beutel kauft und die Karte genehmigt wird
    Dann sieht er "Danke für deine Bestellung"
    Und es gibt genau 1 Bestellung für "Assam Breakfast"
    Und 11 Beutel "Assam Breakfast" sind auf Lager

  Szenario: Eine abgelehnte Karte lässt den Warenkorb stehen
    Angenommen "Assam Breakfast" kostet 6,50 € und 12 Beutel sind auf Lager
    Wenn ein Gast einen Beutel kauft und die Karte abgelehnt wird
    Dann sieht er "Deine Karte wurde abgelehnt"
    Und im Warenkorb liegt noch 1 Beutel "Assam Breakfast"
    Und 12 Beutel "Assam Breakfast" sind auf Lager

Die Zeile @critical oben markiert beide Szenarien. Jedes Szenario liest sich wie ein Satz, den Henrik selbst hätte sagen können: eine Ausgangslage (Angenommen), eine Handlung (Wenn) und ein Ergebnis (Dann). Das zweite Szenario ist der Fehlerzweig aus der Karte, als Test geschrieben.

Hinter jedem Satz steht eine Step Definition in Ruby, die mit Capybara den Browser steuert. Hier die für den Kauf:

Wenn("ein Gast einen Beutel kauft und die Karte {word} wird") do |result|
  # genehmigt oder abgelehnt: so antwortet die Attrappe des Zahlungsanbieters
  FakePaymentProvider.next_result = result == "genehmigt" ? :approved : :declined
  visit product_path(Product.find_by!(name: "Assam Breakfast"))
  click_button "In den Warenkorb"
  click_link "Zur Kasse"
  fill_in "E-Mail", with: "gast@teekontorhansen.example"
  click_button "Jetzt bezahlen"
end

Zeile für Zeile: {word} fängt "genehmigt" oder "abgelehnt" aus dem Satz auf. Die erste Codezeile sagt einer Attrappe des Zahlungsanbieters (einem Stellvertreter für den echten, nur im Test), wie sie antworten soll. visit öffnet die Produktseite, click_button und click_link drücken, was eine Kundin drücken würde, und fill_in tippt die Mailadresse ins Feld. Nichts davon weiß, wie die Kasse innen gebaut ist. Genau das ist der Punkt: Schreibt Jana den Code der Kasse neu, beschreiben diese Tests immer noch, was die Kundin erleben muss.

Um nur die kritischen Szenarien laufen zu lassen, tippt Jana bundle exec cucumber --tags @critical. Hätte der Shop ein Next.js Frontend mit Playwright Tests, funktioniert dieselbe Idee dort: Ein Test bekommt tag: '@critical', und npx playwright test --grep @critical startet nur diese4. RSpec kann dasselbe mit rspec --tag critical5.

Absicherung zwei: Vertragstests an der Grenze zu fremden Systemen

Die riskantesten Schritte auf den meisten kritischen Pfaden liegen an einer Grenze: dort, wo dein Shop mit dem Zahlungsanbieter, dem Mailversand oder dem Lager spricht. Deine End to End Tests setzen dort einen Stellvertreter ein, weil du nicht bei jedem Testlauf eine echte Karte belasten kannst. Also brauchst du eine zweite Absicherung, die prüft, ob der Stellvertreter noch zur Wirklichkeit passt.

Das ist ein Vertragstest (Contract Test). Das Projekt Pact definiert Contract Testing als Technik, einen Integrationspunkt zu testen, indem jede Anwendung für sich geprüft wird6. Jede Seite prüft sich gegen eine gemeinsame Beschreibung der Nachrichten, die zwischen beiden laufen. Kontrollierst du beide Seiten, übernimmt ein Werkzeug wie Pact beide Hälften (der Artikel über API Tests zeigt, wie). Ist die andere Seite ein externer Anbieter, kannst du seine Hälfte nicht laufen lassen. Deine eigene kannst du trotzdem festnageln: Zeichne eine echte Nachricht aus dem Testmodus des Anbieters auf, leg sie ins Repository und teste, dass dein Code jedes Feld liest, auf das er sich verlässt.

Beispiel: den Webhook der Zahlung festnageln

Jana speichert eine echte Nachricht "Zahlung erfolgreich" aus dem Testmodus des Anbieters als test/fixtures/files/payment_succeeded.json und schreibt diesen Minitest:

require "test_helper"

class PaymentWebhookContractTest < ActiveSupport::TestCase
  test "liest die Felder, auf die sich der Shop verlässt" do
    payload = JSON.parse(file_fixture("payment_succeeded.json").read)
    event = PaymentWebhook.parse(payload)

    assert_equal "pi_test_123", event.payment_id
    assert_equal 650, event.amount_cents
    assert_equal "eur", event.currency
  end
end

file_fixture lädt die aufgezeichnete Nachricht. PaymentWebhook.parse ist der eigene Code des Shops, der die Nachricht des Anbieters in etwas übersetzt, das die Bestelllogik versteht. Die drei Zeilen mit assert_equal prüfen die drei Fakten, an denen der kritische Pfad hängt: welche Zahlung, wie viel (in Cent, 6,50 € sind also 650) und in welcher Währung. Benennt der Anbieter in einer neuen Version ein Feld um, frischt Jana die Aufzeichnung auf, dieser Test schlägt fehl, und sie erfährt es am eigenen Laptop statt durch eine Bestellung, die nie rausgeht.

Absicherung drei: ein Release Gate, das die kritischen Tests zuerst laufen lässt

Ein Release Gate ist eine automatische Prüfung zwischen einer Änderung und der Produktion: Schlagen die Tests fehl, findet das Release nicht statt. Jedes Release, das ich ausliefere, geht durch eines. Für den kritischen Pfad lohnt eine Verfeinerung, die Reihenfolge. Lass die kritischen Tests zuerst und für sich laufen, dann lässt eine kaputte Kasse das Release nach Minuten scheitern statt erst nach der ganzen Testsuite.

GitHub Actions, die in GitHub eingebaute Automatisierung, drückt das mit einem Schlüsselwort aus. Ein Job kann erklären, dass er einen anderen Job braucht (needs), und die Dokumentation ist eindeutig: Scheitert ein Job oder wird er übersprungen, werden alle Jobs übersprungen, die ihn brauchen7. Ein Deploy Job, der die kritischen Tests braucht, kann also nicht laufen, wenn sie scheitern.

Beispiel: das Release Gate des Teeshops

Jana legt .github/workflows/release.yml an:

name: Release Gate
on:
  push:
    branches: [main]

env:
  RAILS_ENV: test

jobs:
  critical:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: ruby/setup-ruby@v1
        with:
          bundler-cache: true
      - run: bin/rails db:prepare
      - run: bundle exec cucumber --tags @critical

  full_suite:
    needs: critical
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: ruby/setup-ruby@v1
        with:
          bundler-cache: true
      - run: bin/rails db:prepare
      - run: bin/rails test:all
      - run: bundle exec cucumber --tags "not @critical"

  deploy:
    needs: [critical, full_suite]
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/checkout@v4
      - run: bin/deploy

Lies es von oben. on: push: branches: [main] startet den Ablauf, sobald Code auf dem Hauptzweig landet. env setzt die Testumgebung für jeden Schritt. Der Job critical holt den Code, installiert Ruby und die Gems, bereitet eine Testdatenbank vor und führt nur die Szenarien mit dem Tag @critical aus. Der Job full_suite hat needs: critical, startet also nur, wenn die kritischen Tests grün sind, und führt dann alle Unit und Systemtests und die übrigen Szenarien aus (der Ausdruck not @critical überspringt die schon gelaufenen). Der Job deploy braucht beide, also stoppt ihn ein einziger roter Test irgendwo. bin/deploy steht für den Deploybefehl des Projekts. Die Zeile environment: production ist der Haken für die nächste Absicherung.

Absicherung vier: den verifizierten Pfad hinter einer Freigabe einfrieren

Tests fangen eine Änderung, die den kritischen Pfad versehentlich bricht. Sie fangen keine Änderung, die ihn absichtlich verändert und die Tests gleich mit anpasst. Jemand schreibt die Rabattregel um, passt das Szenario an, bis es grün ist, und das Release Gate lässt alles durch. Jeder Test ist grün, und der Shop macht jetzt etwas, dem der Inhaber nie zugestimmt hat.

Deshalb friere ich verifizierte kritische Pfade hinter einer Freigabe ein: Sobald der Inhaber bestätigt hat, dass sich der Pfad richtig verhält, braucht jede Änderung daran seine ausdrückliche Zustimmung. GitHub bietet dafür zwei Mechanismen, die gut zusammenspielen.

Der erste ist eine Datei CODEOWNERS. Sie legt fest, wem welche Dateien gehören, und diese Code Owner werden automatisch um ein Review gebeten, sobald ein Pull Request (eine vorgeschlagene Änderung) ihre Dateien berührt. Mit der Einstellung "Require review from Code Owners" im Branchschutz lässt sich die Änderung erst zusammenführen, wenn ein Owner zustimmt8.

Der zweite ist die Deployment Umgebung. Ein Job, der eine Umgebung nennt, wartet, bis deren Schutzregeln erfüllt sind. Eine dieser Regeln ist eine Liste von Pflichtprüfern, bis zu sechs Personen oder Teams, von denen eine zustimmen muss, bevor der Job läuft9 7. Eine ehrliche Grenze: Im kostenlosen GitHub Plan gibt es Umgebungen nur für öffentliche Repositories9, ein privates Shop Repository braucht für diesen Teil also einen bezahlten Plan.

Beispiel: die verifizierte Kasse einfrieren

Jana legt .github/CODEOWNERS an:

# Verifizierter kritischer Pfad: Änderungen brauchen eine Freigabe
/docs/critical_path.md        @henrik-teekontor
/features/critical/           @henrik-teekontor @jana-teekontor
/app/services/checkout/       @jana-teekontor
/app/models/order.rb          @jana-teekontor

Jede Zeile ist ein Pfad, gefolgt von den Menschen, denen er gehört. Die Klartextdatei und die kritischen Szenarien nennen Henrik, weil sie beschreiben, was das Geschäft verspricht. Der Code der Kasse nennt Jana, weil sie ihn versteht. Sie schaltet "Require review from Code Owners" für den Hauptzweig ein und trägt sich selbst als Pflichtprüferin der Umgebung production ein.

Drei Wochen später ändert ein externer Entwickler, der bei einer Sommeraktion hilft, die Rundung von Rabatten und passt ein kritisches Szenario an, bis es grün ist. Der Pull Request bittet automatisch Henrik um ein Review, weil sich ein Szenario geändert hat. Henrik liest eine Zeile: "Ein Code über 15 % auf 6,50 € gibt jetzt 0,97 € Rabatt statt 0,98 €". Er fragt nach dem Grund, und der Entwickler repariert stattdessen die Rundung. Die Tests sind nie rot geworden. Die Freigabe hat es gefangen.

Absicherung fünf: ein Smoke Test nach jedem Deploy

Tests laufen gegen eine Kopie des Shops. Die Produktion ist ein anderer Ort, mit echter Konfiguration, echten Zugangsdaten und einem echten Netzwerk. Ein Smoke Test ist eine schnelle Prüfung direkt nach einem Deploy, ob die Seite live erreichbar ist und ihre Seiten laden. Der Name kommt aus der Elektronik: einschalten und schauen, ob es raucht.

Rails bringt einen kleinen Ausgangspunkt mit. Neue Rails Anwendungen haben unter /up einen Health Check, der Status 200 liefert, wenn die Anwendung ohne Ausnahme gestartet ist, sonst 500. Die Dokumentation sagt klar, dass er nicht den Zustand aller Abhängigkeiten wie der Datenbank widerspiegelt10. Er sagt dir, dass die Anwendung läuft. Er sagt dir nicht, dass jemand Tee kaufen kann.

Deshalb lasse ich nach jedem Deploy einen Smoke Test laufen, der jede Seite der Website abruft, und werte alles außer einer 200 als gescheitertes Release.

Beispiel: der Smoke Test des Teeshops

Jana schreibt ein kurzes Skript, bin/smoke.mjs, das direkt nach bin/deploy läuft:

// Jede Seite aus der Sitemap abrufen, bei allem außer 200 scheitern
const base = process.argv[2] ?? "https://teekontorhansen.example";
const xml = await (await fetch(`${base}/sitemap.xml`)).text();
const urls = [...xml.matchAll(/<loc>(.*?)<\/loc>/g)].map((m) => m[1]);

let failed = 0;
for (const url of [`${base}/up`, ...urls]) {
  const res = await fetch(url, { redirect: "manual" });
  if (res.status !== 200) {
    console.error(`${res.status} ${url}`);
    failed += 1;
  }
}
console.log(`${urls.length + 1} Seiten geprüft, ${failed} fehlgeschlagen`);
process.exit(failed ? 1 : 0);

Das Skript liest die Sitemap (die Datei, die jede öffentliche Seite auflistet), zieht jede Adresse heraus, nimmt den Health Check /up dazu und ruft alles ab. redirect: "manual" verhindert, dass es einer Weiterleitung still folgt, also zählt eine Seite, die Leute plötzlich woandershin schickt, als Fehler. Jeder Fehler wird ausgegeben, und das Skript endet mit Code 1, was den Deploy Job rot färbt. Es kauft in der Produktion keinen Tee (das würde echte Bestellungen erzeugen). Für die Geldkette selbst verlässt sich Jana auf die nächste Absicherung.

Absicherung sechs: den Pfad in der Produktion beobachten

Irgendwann bricht in der Produktion etwas, das kein Test vorhergesehen hat: Der Zahlungsanbieter fällt aus, ein Zertifikat läuft ab, eine Warteschlange bleibt stehen. Die letzte Absicherung ist das Monitoring, und den nützlichsten Rat dazu gibt Googles Buch über Site Reliability Engineering. Seine vier goldenen Signale für ein System mit Nutzerkontakt sind Latenz, Traffic, Fehler und Auslastung, und es empfiehlt, viel mehr Aufwand in das Erkennen von Symptomen zu stecken als von Ursachen11. Ein Symptom ist, was die Kundschaft spürt ("niemand kann zahlen"). Eine Ursache ist das Warum ("der Verbindungspool der Datenbank ist voll"). Dasselbe Kapitel besteht darauf, dass jeder Alarm, der einen Menschen weckt, eine Handlung erfordern muss11.

Bei einem Shop ist das klarste Symptom auf dem kritischen Pfad die Bestellung. Hören die Bestellungen auf, ist etwas auf dem Pfad kaputt, egal aus welchem Grund.

Beispiel: wenn Stille Ärger bedeutet

Zu den Geschäftszeiten nimmt Teekontor Hansen im Schnitt 6 bezahlte Bestellungen pro Stunde an (für dieses Beispiel erfunden). Jana will einen Alarm, wenn Bestellungen ausbleiben, aber keinen, der bei einer ganz normalen ruhigen Phase losgeht. Ab wann ist Stille verdächtig?

Kommen Bestellungen unabhängig voneinander mit einer gleichmäßigen Durchschnittsrate, folgt die Chance, in einem Zeitfenster gar keine zu sehen, dem Poisson Modell:

P(keine Bestellung in t)=e−λtP(\text{keine Bestellung in } t) = e^{-\lambda t}

Dabei ist λ\lambda die durchschnittliche Zahl der Bestellungen pro Stunde, tt die Länge des Fensters in Stunden und e≈2,718e \approx 2{,}718 die Basis des natürlichen Logarithmus. Die Grundlagen: Wahrscheinlichkeit erklären solche Chancen von Anfang an.

Probier zuerst ein Fenster von 15 Minuten, also t=0,25t = 0{,}25. Dann ist P=e−6×0,25=e−1,5≈0,223P = e^{-6 \times 0{,}25} = e^{-1{,}5} \approx 0{,}223, eine Chance von 22 %, dass es rein zufällig still bleibt. Ein Alarm bei 15 Minuten Pause würde an einem völlig gesunden Tag etwa in jedem fünften Fenster losgehen, und Jana würde lernen, ihn zu ignorieren. Jetzt 45 Minuten, also t=0,75t = 0{,}75. Dann ist P=e−6×0,75=e−4,5≈0,011P = e^{-6 \times 0{,}75} = e^{-4{,}5} \approx 0{,}011, rund 1 %.

Eine Stille von 45 Minuten während der Geschäftszeiten ist selten genug, dass wahrscheinlich etwas nicht stimmt. Also wird das der Alarm: "Keine bezahlte Bestellung seit 45 Minuten, zwischen 8 und 22 Uhr". Außerhalb dieser Zeiten gilt die Annahme der gleichmäßigen Rate nicht (nachts ist es immer ruhig), also schläft der Alarm. Geht er los, lässt Jana als Erstes die kritischen Szenarien gegen die Stagingumgebung laufen und gibt eine Testbestellung auf. Der Alarm nennt ein Symptom, der kritische Pfad sagt ihr, wo sie suchen muss.

Ob alle sechs Absicherungen auf Dauer greifen, misst DORA, das Forschungsprogramm hinter den bekanntesten Kennzahlen der Softwareauslieferung, mit der Change Fail Rate: dem Anteil der Deployments, die direkt danach ein Eingreifen erfordern12. Jana zählt sie pro Quartal. Steigt sie, hat der kritische Pfad irgendwo eine Lücke.

Den Pfad im Alltag im Blick behalten

Die Absicherungen oben laufen von selbst. Der Teil der Entwicklerin ist, den kritischen Pfad beim Arbeiten im Kopf zu behalten, damit er sich nie vom Code entfernt. Drei Gewohnheiten erledigen das meiste. Lies docs/critical_path.md, bevor du eine Änderung beginnst, und frag dich: Berührt das einen nummerierten Schritt? Lass die kritischen Tests auf deinem eigenen Rechner zuerst laufen, vor der ganzen Suite, mit bundle exec cucumber --tags @critical. Und kommt ein neues Feature zur Geldkette oder zur rechtlichen Kette dazu, dann trag es in die Datei ein, bewerte es, zeichne es ein und tagge sein Szenario im selben Pull Request, damit Datei und Tests nie auseinanderlaufen.

Dieselbe Datei hilft auch KI Assistenten beim Programmieren. Ein Assistent startet jede Sitzung ohne Erinnerung an die letzte. Eine Datei mit dem kritischen Pfad im Repository, auf die die Anweisungsdatei des Projekts verweist, ist der Weg, auf dem er erfährt, welche Teile er nicht ohne Rückfrage anfassen darf. Kapitel 8 dieser Serie, testgetriebene Entwicklung mit KI, zeigt, wie du diese Regel einrichtest.

Beispiel: eine kleine Änderung an einem Dienstag

Henrik wünscht sich eine neue Rabattart: "Drei Beutel kaufen, der günstigste ist gratis". Jana öffnet die Datei mit dem kritischen Pfad. Rabattcodes sind Schritt drei, also liegt diese Änderung auf dem Pfad.

Sie schreibt ein neues Szenario in features/critical/discounts.feature, mit dem Tag @critical, für drei Beutel zu 6,50 €, 6,50 € und 4,20 €, und erwartet 4,20 € Rabatt und eine Summe von 13,00 €. Sie startet bundle exec cucumber --tags @critical und sieht das neue Szenario scheitern, weil es das Feature noch nicht gibt. Sie baut es, Test zuerst, bis dieses und alle anderen kritischen Szenarien grün sind, dann lässt sie die ganze Suite laufen.

Sie öffnet den Pull Request. CODEOWNERS bittet Henrik um ein Review, weil die Änderung features/critical/ berührt. Henrik liest das Szenario, das in klarem Deutsch dasteht, und gibt es frei. Das Release Gate lässt zuerst die kritischen Tests laufen, dann die ganze Suite, und wartet dann auf Janas Freigabe für die Produktionsumgebung. Sie gibt frei, der Deploy läuft, der Smoke Test ruft jede Seite ab und ist grün, und das Release bekommt seine Versionsnummer im Release Register. Zwanzig Minuten nach dem Deploy kommt eine Bestellung mit dem neuen Rabatt, und der Bestellalarm bleibt still.

Was du verlangen solltest, wenn du Software beauftragst

Bist du der Henrik in dieser Geschichte und schreibt jemand anderes deinen Code, musst du kein YAML lesen können, um zu wissen, ob dein kritischer Pfad abgesichert ist. Stell fünf Fragen und erwarte auf jede eine klare Antwort.

  1. Kannst du mir unseren kritischen Pfad zeigen, in einfachen Worten, im Repository?
  2. Welche Tests sichern welchen Schritt ab, und kann ich sie lesen?
  3. Stoppt ein fehlgeschlagener kritischer Test ein Release automatisch?
  4. Wer muss eine Änderung am kritischen Pfad freigeben, und ist das technisch erzwungen oder nur abgesprochen?
  5. Was passiert nach einem Deploy, und wer erfährt es, wenn die Bestellungen ausbleiben?

Beispiel: zwei Antworten auf Frage drei

Wer sagt "Wir testen immer vor dem Release", beschreibt eine Gewohnheit. Wer sagt "Der Deploy Job braucht in unserem Workflow den kritischen Job, er kann also nicht laufen, wenn ein kritisches Szenario scheitert, und hier ist der Lauf vom Release letzten Donnerstag", beschreibt eine Absicherung und zeigt den Beleg dafür. Nur die zweite übersteht einen hektischen Freitag. Der Artikel über Compliance Nachweise erklärt, wie dieser Beleg auch Prüfern und Versicherern dient.

Fazit

Jedes Produkt hat eine kurze Kette von Schritten, die das Geld hereinholt und das Unternehmen auf der richtigen Seite des Gesetzes hält. Du findest sie, indem du dem Geld, dem Gesetz und der Kundschaft folgst. Bewerte jeden Schritt mit Wahrscheinlichkeit mal Auswirkung, und lass jede gesetzliche Pflicht auf dem Pfad, egal wie ihr Wert aussieht. Bild ihn von oben nach unten mit jedem Fehlerzweig ab und schreib ihn ins Repository, wo der Code liegt und wo alle, die daran arbeiten (auch die KI Assistenten), ihn sehen.

Dann sichere ihn sechsfach ab: End to End Szenarien mit dem Tag @critical, Vertragstests an den Grenzen, ein Release Gate, das die kritischen Tests zuerst laufen lässt und den Deploy blockiert, eine Freigabe, die den verifizierten Pfad einfriert, ein Smoke Test nach jedem Deploy und ein Alarm auf das Symptom, das am meisten zählt. Nichts davon ist kompliziert. Alles zusammen sorgt dafür, dass der Teil deiner Software, der die Rechnungen bezahlt, der Teil ist, der dich nie überrascht.

Die nächsten Kapitel drehen sich darum, was passiert, wenn trotzdem etwas schiefgeht, angefangen mit Fehler und Exceptions erklärt.

Wenn du wissen willst, wie dein eigener kritischer Pfad aussieht und ob ihn irgendetwas wirklich absichert, buch den kostenlosen Workshop: Wir zeichnen ihn gemeinsam an deinem Produkt, und die ersten zwei Wochen Arbeit gehen auf mich.

Quellen

  1. 1.

    Verordnung (EU) 2016/679 (Datenschutz Grundverordnung), Artikel 12 Absatz 3, EUR Lex, 2016, https://eur-lex.europa.eu/eli/reg/2016/679/oj/deu

  2. 2.

    International Software Testing Qualifications Board (ISTQB), Certified Tester Foundation Level Syllabus v4.0.1, Abschnitt 5.2 Risikomanagement, 2024, https://istqb.org/wp-content/uploads/2024/11/ISTQB_CTFL_Syllabus_v4.0.1.pdf

  3. 3.

    Cucumber, Reference (tags and tag expressions), Cucumber Dokumentation, abgerufen im November 2026, https://cucumber.io/docs/cucumber/api/

  4. 4.

    Microsoft, Annotations: tag tests, Playwright Dokumentation, abgerufen im November 2026, https://playwright.dev/docs/test-annotations

  5. 5.

    RSpec, Command line: tag option, RSpec Core 3.13 Dokumentation, abgerufen im November 2026, https://rspec.info/features/3-13/rspec-core/command-line/tag/

  6. 6.

    Pact, Introduction (what is contract testing), Pact Dokumentation, abgerufen im November 2026, https://docs.pact.io/

  7. 7.

    GitHub, Workflow syntax for GitHub Actions (jobs.job_id.needs und jobs.job_id.environment), GitHub Docs, abgerufen im November 2026, https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions

  8. 8.
  9. 9.

    GitHub, Managing environments for deployment, GitHub Docs, abgerufen im November 2026, https://docs.github.com/en/actions/managing-workflow-runs-and-deployments/managing-deployments/managing-environments-for-deployment

  10. 10.

    Ruby on Rails, Rails::HealthController, Rails API Dokumentation, abgerufen im November 2026, https://api.rubyonrails.org/classes/Rails/HealthController.html

  11. 11.

    Rob Ewaschuk, herausgegeben von Betsy Beyer, Monitoring distributed systems, in Site Reliability Engineering, O'Reilly Media, 2016, https://sre.google/sre-book/monitoring-distributed-systems/

  12. 12.

    DORA (Google Cloud), DORA's software delivery performance metrics, abgerufen im November 2026, https://dora.dev/guides/dora-metrics/