Wissen · Softwarequalität & Testing
Software Testing und Softwarequalität: der große Ratgeber
Software Testing prüft, ob ein Programm tut, was es soll. Softwarequalität fragt, ob es das auch morgen noch tut – zuverlässig, sicher und änderbar. Dieser Ratgeber erklärt beides zusammen: Teststufen und Testarten, Unit-Tests, TDD und Gherkin, Code Review, Clean Code, technische Schulden und was KI daran ändert. Mit Beispielen, Zahlen und Quellen.
Überblick
Warum Testen und Qualität zusammengehören
Die meisten Ratgeber behandeln Software Testing als eigenes Thema: Testarten, Werkzeuge, Automatisierung. Das greift zu kurz. Tests finden Fehler, aber sie verhindern keine. Ob eine Software in zwei Jahren noch schnell änderbar ist, entscheidet sich vorher – in klaren Anforderungen, lesbarem Code, Reviews und einem Team, das technische Schulden im Blick behält.
Darum führt dieser Ratgeber beides zusammen. Zuerst klären wir, was Softwarequalität überhaupt ist und was schlechte Qualität kostet. Dann geht es um das Testen selbst: Teststufen, Unit-Tests, die wichtigsten Testarten, die Testpyramide, TDD und BDD mit Gherkin. Im dritten Teil folgen die Praktiken, die Qualität im Alltag sichern: Automatisierung, Quality Gates, Code Review, Clean Code, Refactoring und der Umgang mit technischen Schulden. Zum Schluss: wie KI das Bild verändert und welche Tests Dein Projekt wirklich braucht.
Der Ratgeber richtet sich an Entwicklerinnen und Entwickler, an Projektleitungen und an Entscheider, die verstehen wollen, warum Qualität kein Luxus ist. Wo es technisch wird, gibt es Beispiele. Wo Zahlen stehen, steht die Quelle dabei.
Qualitätscheck für Deine Software
Wir sehen uns Code, Tests und Pipeline an und sagen Dir, wo das größte Risiko liegt.
Anfragen ›Passend dazu
1. Was ist Softwarequalität? ›2. Was Softwarefehler kosten ›3. Was ist Software Testing? ›4. Teststufen ›Inhaltsverzeichnis
Teil 1 · Grundlagen
Was ist Softwarequalität?
Softwarequalität beschreibt, wie gut eine Software die Anforderungen ihrer Nutzer und Betreiber erfüllt – heute und bei künftigen Änderungen. Der international verbreitete Maßstab ist das Qualitätsmodell der Norm ISO/IEC 25010, in der Fassung von 2023 mit neun Merkmalen.
Funktionale Eignung
Tut die Software, was sie soll – vollständig, korrekt und angemessen? Das ist das Merkmal, an das alle zuerst denken.
Leistungseffizienz
Antwortzeiten, Ressourcenverbrauch und Kapazität. Eine Suche, die zehn Sekunden braucht, ist funktional richtig und trotzdem schlecht.
Kompatibilität
Arbeitet die Software mit anderen Systemen zusammen und verträgt sie sich mit ihnen in derselben Umgebung? Für Schnittstellen zu ERP und CRM entscheidend.
Interaktionsfähigkeit
Früher „Benutzbarkeit“: Erlernbarkeit, Bedienbarkeit, Schutz vor Fehlbedienung und Barrierefreiheit.
Zuverlässigkeit
Läuft die Software stabil, ist sie verfügbar, verkraftet sie Fehler und kommt sie danach wieder auf die Beine?
Sicherheit (Security)
Vertraulichkeit, Integrität, Nachvollziehbarkeit und Schutz vor Angriffen. Mehr unter Cloud- und Anwendungssicherheit.
Wartbarkeit
Wie leicht lässt sich die Software verstehen, ändern, testen und wiederverwenden? Hier entstehen oder verschwinden technische Schulden.
Flexibilität
Früher „Übertragbarkeit“: Anpassung an neue Umgebungen, Installation, Skalierung und Austausch von Komponenten.
Betriebssicherheit (Safety)
Neu seit 2023: Vermeidet die Software Gefahren für Menschen, Umwelt und Sachwerte – wichtig etwa in Produktion und Medizintechnik.
Zwei Sichten helfen bei der Einordnung. Die äußere Qualität spüren die Nutzer: Funktion, Geschwindigkeit, Bedienbarkeit, Verfügbarkeit. Die innere Qualität spürt das Entwicklungsteam: verständlicher Code, wenige Abhängigkeiten, gute Tests. Innere Qualität sieht niemand im Vertrieb – aber sie entscheidet, ob die nächste Funktion zwei Tage oder zwei Wochen dauert.
Und drei Begriffe, die oft verwechselt werden: Qualitätssicherung (Quality Assurance) umfasst alles, was Fehler verhindert – Prozesse, Richtlinien, Reviews. Qualitätskontrolle (Quality Control) prüft Ergebnisse. Testen ist das wichtigste Werkzeug der Qualitätskontrolle, aber eben nur eines davon. Wer nur testet, findet Fehler; wer Qualität sichert, macht weniger davon.
Zahlen
Was kosten Softwarefehler? Die Zahlen mit Quelle
„Früh finden ist billiger“ – das steht in fast jedem Ratgeber, selten mit Beleg. Hier die Zahlen, die sich auf Primärquellen zurückführen lassen.
✓Belegte Zahlen
- 2,41 Billionen US-Dollar pro Jahr kostet schlechte Softwarequalität allein in den USA, die angesammelten technischen Schulden schätzt dieselbe Studie auf rund 1,52 Billionen US-Dollar (CISQ, Cost of Poor Software Quality, 2022).
- 59,5 Milliarden US-Dollar jährlich kostete eine unzureichende Testinfrastruktur die US-Wirtschaft, rund 22,2 Milliarden wären durch bessere Tests vermeidbar gewesen (NIST, 2002) – alt, aber bis heute der Referenzwert.
- 17,3 von 41,1 Stunden pro Woche verbrachten befragte Entwickler mit Wartung – Fehlersuche, schlechtem Code, Refactoring –, also gut 40 % ihrer Zeit; allein 13,5 Stunden entfielen auf technische Schulden (Stripe, The Developer Coefficient, 2018).
Mythencheck: „In Produktion 100-mal teurer“
Eine oft zitierte Grafik behauptet, ein Fehler koste in Produktion hundertmal mehr als in der Entwurfsphase, Quelle angeblich das „IBM Systems Sciences Institute“. Eine Primärstudie dazu ist nicht auffindbar. Wir verwenden die Zahl deshalb nicht.
Richtig bleibt die Richtung: Ein Fehler, den ein Unit-Test in Sekunden meldet, kostet Minuten. Derselbe Fehler beim Kunden kostet Fehlersuche, Hotfix, Kommunikation, im schlimmsten Fall Umsatz und Vertrauen. Wie stark der Faktor ist, hängt vom Fehler ab – aber er ist immer größer als eins.
Fehler, Defekt, Ausfall: drei Begriffe
Im Testen unterscheidet man sauber: Ein Mensch macht einen Fehler (Error), etwa ein Denkfehler bei einer Rabattregel. Dadurch steckt ein Defekt (Fault, umgangssprachlich Bug) im Code. Wird der fehlerhafte Code ausgeführt, kommt es zum Ausfall (Failure): Der Kunde bekommt den falschen Preis. Nicht jeder Defekt führt sofort zum Ausfall – manche schlummern jahrelang, bis eine seltene Eingabe sie weckt.
Genau deshalb kann man Software nicht „fertig testen“. Schon ein Formular mit zehn Ankreuzfeldern hat 210 = 1.024 mögliche Kombinationen – multipliziert mit allen Eingabefeldern, Browsern und Datenständen wird vollständiges Testen unmöglich. Gutes Testen heißt darum: die richtigen Fälle auswählen.
Teil 2 · Testen
Was ist Software Testing?
Software Testing – auf Deutsch Softwaretest – ist die gezielte Prüfung einer Software, um Abweichungen zwischen erwartetem und tatsächlichem Verhalten zu finden und das Risiko eines Einsatzes einzuschätzen. Der Informatiker Edsger W. Dijkstra hat die Grenze dabei klar benannt: Tests können zeigen, dass Fehler vorhanden sind, aber nie, dass keine da sind.
Testen ist deshalb vor allem Risikomanagement. Die Frage lautet nicht „Ist alles getestet?“, sondern „Wissen wir genug, um diese Version guten Gewissens freizugeben?“.
Statisch und dynamisch
Beim statischen Testen wird Code oder ein Dokument geprüft, ohne es auszuführen: Reviews, Lesen von Anforderungen, automatische Analyse durch Linter und Sicherheitsscanner. Beim dynamischen Testen läuft die Software und wird mit Eingaben gefüttert. Statische Prüfungen finden Fehler am frühesten, dynamische zeigen, wie sich das System wirklich verhält.
Black-Box, White-Box, Grey-Box
Beim Black-Box-Test kennt der Testende nur die Anforderungen, nicht den Code – typisch für Fach- und Abnahmetests. Beim White-Box-Test ist der Code bekannt, und Tests zielen auf Verzweigungen und Pfade. Grey-Box mischt beides, etwa wenn ein API-Test die Datenbankstruktur kennt.
Teststufe, Testart, Testtechnik: drei verschiedene Fragen
Viele Ratgeber werfen alles in eine Liste. Hilfreicher ist die Trennung, die auch die Norm ISO/IEC/IEEE 29119 und das ISTQB verwenden:
Teststufe: Was wird getestet?
Eine einzelne Einheit, das Zusammenspiel mehrerer Teile, das ganze System oder die Lösung aus Sicht des Fachbereichs.
Testart: Welche Eigenschaft?
Funktion, Leistung, Sicherheit, Bedienbarkeit – also die Qualitätsmerkmale aus ISO 25010. Dazu Regressions- und Bestätigungstests nach Änderungen.
Testtechnik: Wie finde ich gute Fälle?
Äquivalenzklassen, Grenzwertanalyse, Entscheidungstabellen, Zustandsübergänge, erfahrungsbasiertes Testen.
Ein Beispiel für Testtechniken: Ein Shop versendet ab 50 € Bestellwert kostenlos. Statt jeden Betrag zu testen, bildest Du Äquivalenzklassen (unter 50 €, ab 50 €) und prüfst die Grenzwerte: 49,99 €, 50,00 € und 50,01 €. Genau dort verstecken sich die meisten Fehler – ein „größer“ statt „größer gleich“ reicht.
Teststufen
Die vier Teststufen: von Unit-Test bis Abnahmetest
Unit-Test (Komponententest)
Prüft eine einzelne Funktion oder Klasse isoliert. Schnell, billig, zahlreich. Geschrieben von den Entwicklern selbst, meist im selben Moment wie der Code. Mehr dazu im nächsten Abschnitt.
Integrationstest
Prüft, ob Teile korrekt zusammenarbeiten: Code mit Datenbank, ein Dienst mit einem anderen, die eigene Anwendung mit der Schnittstelle zum ERP. Hier fallen Fehler auf, die in isolierten Unit-Tests unsichtbar bleiben – falsche Datenformate, Zeitzonen, Transaktionen.
Systemtest und End-to-End-Test
Prüft die gesamte Anwendung in einer möglichst echten Umgebung, oft über die Oberfläche: Kunde meldet sich an, legt Ware in den Warenkorb, bezahlt, erhält eine Bestätigung. Wertvoll, aber langsam und anfällig – deshalb gezielt für die wichtigsten Abläufe.
Abnahmetest
Prüft aus Sicht von Fachbereich, Kunde oder Betreiber, ob die Lösung den vereinbarten Zweck erfüllt. Grundlage sind Akzeptanzkriterien, idealerweise schon beim Schreiben der Anforderungen festgelegt – mehr dazu unter Lastenheft, Pflichtenheft und Use Cases.
Integrationstest heißt übrigens nicht automatisch Ende-zu-Ende. Ein Integrationstest kann sehr klein sein: Funktioniert die Datenbankabfrage gegen eine echte Datenbank? Der Ende-zu-Ende-Test prüft dagegen einen ganzen Geschäftsablauf über alle Schichten hinweg. Wer beides vermischt, baut zu viele langsame Tests.
Unit Testing
Unit Testing verständlich erklärt: Was ist ein Unit-Test?
Ein Unit-Test prüft die kleinste sinnvolle Einheit eines Programms – meist eine Funktion oder Klasse – unabhängig vom Rest. Datenbank, Netzwerk oder Dateisystem werden dabei durch Platzhalter ersetzt. So läuft ein Test in Millisekunden, und Hunderte davon sind nach jeder Änderung in wenigen Sekunden durch.
Der eigentliche Wert liegt weniger in der Fehlersuche als in der Sicherheit beim Ändern. Wer eine Funktion umbaut und danach alle Tests grün sieht, weiß: Das bisherige Verhalten ist erhalten. Unit-Tests sind damit die Voraussetzung für Refactoring – und nebenbei eine lebende Dokumentation, die nie veraltet.
Beispiel: ein Unit-Test im Muster Arrange, Act, Assert
Die Versandkostenregel von oben als Test in Python mit pytest. Jeder Test hat drei Teile: Vorbereiten (Arrange), Ausführen (Act), Prüfen (Assert).
def test_kostenlos_ab_50_euro():
# Arrange
bestellwert = 50.00
# Act
kosten = versandkosten(bestellwert)
# Assert
assert kosten == 0.00
def test_unter_50_euro_kostet_versand():
assert versandkosten(49.99) == 4.90
In Java heißt das Werkzeug JUnit, in JavaScript und TypeScript Jest oder Vitest, in PHP PHPUnit, in C# xUnit oder NUnit. Das Prinzip ist überall gleich.
✓Merkmale guter Unit-Tests
- Schnell: Millisekunden, nicht Sekunden.
- Isoliert: unabhängig von anderen Tests und von der Reihenfolge.
- Wiederholbar: gleiches Ergebnis auf jedem Rechner, zu jeder Uhrzeit.
- Eine Aussage pro Test, sprechender Name.
- Prüft Verhalten, nicht interne Details – sonst bricht er bei jedem Umbau.
- So sauber geschrieben wie der Produktivcode.
Mocks, Stubs und Test Doubles
Damit ein Unit-Test isoliert bleibt, ersetzt man Abhängigkeiten durch Doubles. Ein Stub liefert feste Antworten („die Steuer-API gibt 19 % zurück“). Ein Mock prüft zusätzlich, ob er richtig aufgerufen wurde („wurde genau eine Bestätigungsmail verschickt?“). Ein Fake ist eine vereinfachte Arbeitsversion, etwa eine Datenbank im Arbeitsspeicher.
Vorsicht vor zu vielen Mocks: Ein Test, der nur noch prüft, ob Mocks in der richtigen Reihenfolge aufgerufen werden, testet die Implementierung statt des Verhaltens.
Code Coverage richtig lesen
Die Testabdeckung zeigt, welcher Anteil des Codes bei den Tests ausgeführt wurde. Sie sagt, wo sicher nicht getestet wurde – aber nicht, ob gut getestet wurde. 85 % Abdeckung helfen wenig, wenn die heutige Änderung genau in den übrigen 15 % liegt. Sinnvoller als ein Gesamtziel ist deshalb eine Mindestabdeckung für neuen und geänderten Code.
Testarten
Die wichtigsten Testarten im Überblick
Testarten beantworten die Frage, welche Eigenschaft geprüft wird. Sie lassen sich auf jeder Teststufe einsetzen: Ein Lasttest kann eine einzelne Schnittstelle oder das ganze System betreffen.
Regressionstest
Prüft nach jeder Änderung, ob bisher Funktionierendes weiter funktioniert. Der wichtigste Grund, Tests zu automatisieren: Niemand klickt bei jedem Release dieselben 300 Fälle von Hand durch.
Smoke-Test
Ein schneller Grundcheck nach Build oder Deployment: Startet die Anwendung, geht der Login, antworten die Schnittstellen? Wenige Minuten, entscheidet über „weiter testen oder zurückrollen“.
Performance- und Lasttest
Misst Antwortzeiten und Verhalten unter erwarteter Last (Lasttest), unter Überlast (Stresstest) und über lange Zeit (Dauertest). Werkzeuge: k6, JMeter, Gatling, Locust.
Sicherheitstest
Statische Analyse auf bekannte Schwachstellen, Prüfung von Abhängigkeiten, dynamische Scans und Penetrationstests. Mehr unter Anwendungssicherheit.
Usability- und Barrierefreiheitstest
Echte Nutzer lösen Aufgaben, Beobachter notieren Stolperstellen. Für viele Produkte für Verbraucher gilt seit 28. Juni 2025 das Barrierefreiheitsstärkungsgesetz – Barrierefreiheit gehört damit in die Testplanung.
Exploratives Testen
Erfahrene Tester erkunden die Software ohne festes Drehbuch, aber mit Ziel und Zeitrahmen, etwa einer zweistündigen Session zu „Rückerstattungen“. Findet Fehler, an die niemand beim Schreiben der Testfälle gedacht hat.
Kompatibilitäts- und Lokalisierungstest
Läuft die Anwendung in allen Browsern, auf allen Geräten, mit anderen Sprachen, Datumsformaten und Währungen? Für Exporteure im Mittelstand oft unterschätzt.
Flaky Tests
Keine Testart, sondern ein Problem: Tests, die mal grün, mal rot sind, ohne dass sich der Code geändert hat. Ursachen sind meist Zeitabhängigkeiten, Reihenfolge oder externe Dienste. Flaky Tests zerstören das Vertrauen – also sofort reparieren oder entfernen.
Zwei verwandte Begriffe: Ein Bestätigungstest (Retest) prüft, ob ein gemeldeter Fehler wirklich behoben ist. Der Regressionstest prüft, ob die Behebung nichts anderes kaputt gemacht hat. Beide gehören zu jeder Fehlerbehebung.
Teststrategie
Die Testpyramide: wie viele Tests auf welcher Ebene?
Die Testpyramide, bekannt geworden durch Mike Cohn und Martin Fowler, ist eine Faustregel für das Verhältnis der Teststufen. Unten stehen viele schnelle, günstige Unit-Tests. In der Mitte weniger Integrationstests. Oben wenige, gezielte End-to-End-Tests über die Oberfläche. Je höher die Ebene, desto langsamer, teurer und anfälliger sind die Tests – und desto ungenauer zeigen sie, wo genau der Fehler liegt.
✓Pyramide (gesund)
- Oben: wenige End-to-End-Tests für die geschäftskritischen Abläufe
- Mitte: Integrationstests für Datenbank, Schnittstellen, Dienste
- Unten: viele Unit-Tests für Logik und Regeln
- Ergebnis: schnelle Rückmeldung, präzise Fehlermeldung
✕Eistüte (ungesund)
- Oben: viele manuelle Tests und lange Klickstrecken
- Mitte: einige automatisierte Oberflächentests
- Unten: kaum Unit-Tests
- Ergebnis: Tests dauern Stunden, sind instabil, keiner traut ihnen
Die Pyramide ist kein Gesetz. Eine Anwendung, die fast nur Daten zwischen Systemen verschiebt, braucht mehr Integrationstests als Unit-Tests – manche sprechen dann von einer „Testraute“. Entscheidend ist die Frage dahinter: Auf welcher Ebene lässt sich ein Risiko am schnellsten und günstigsten absichern?
Methoden
Test-Driven Development (TDD): erst der Test, dann der Code
Bei der testgetriebenen Entwicklung, eingeführt von Kent Beck Ende der 1990er-Jahre, schreibst Du den Test vor dem Code. Der Ablauf wiederholt sich in kurzen Zyklen von wenigen Minuten.
Red
Schreibe einen Test für das nächste kleine Stück Verhalten. Er schlägt fehl, weil es den Code noch nicht gibt.
Green
Schreibe den einfachsten Code, der den Test bestehen lässt – nicht mehr.
Refactor
Räume Code und Test auf, entferne Wiederholungen, verbessere Namen. Alle Tests bleiben grün.
Was TDD bringt – mit Beleg
Eine viel zitierte Studie von Nagappan, Maximilien, Bhat und Williams (Empirical Software Engineering, 2008) untersuchte vier Teams bei Microsoft und IBM. Die Fehlerdichte vor dem Release lag mit TDD um 40 bis 90 % niedriger als in vergleichbaren Projekten ohne TDD. Der Preis: 15 bis 35 % mehr Zeit in der ersten Entwicklung. Für Software, die jahrelang gepflegt wird, ist das meist ein gutes Geschäft.
Wann TDD weniger passt
Bei Wegwerf-Prototypen, bei Oberflächen, deren Aussehen sich täglich ändert, und bei explorativer Arbeit mit unbekannten Daten. Auch dort helfen Tests – aber oft erst, wenn klar ist, was die Lösung tun soll. TDD ist ein Werkzeug, keine Religion.
Methoden
BDD und Gherkin: Tests, die der Fachbereich lesen kann
Behaviour-Driven Development (BDD) erweitert TDD um die Fachseite. Bevor programmiert wird, beschreiben Fachbereich, Entwicklung und Test gemeinsam an Beispielen, wie sich die Software verhalten soll. Diese Beispiele werden in Gherkin aufgeschrieben – einer einfachen, strukturierten Sprache mit den Schlüsselwörtern Given, When und Then, auf Deutsch Angenommen, Wenn und Dann.
Der Clou: Dieselbe Beschreibung ist Anforderung, Dokumentation und automatisierter Test. Werkzeuge wie Cucumber, SpecFlow oder Behave verknüpfen jeden Satz mit Code, der ihn ausführt. Gherkin ist also die Sprache, Cucumber das Werkzeug.
Funktionalität: Versandkosten im Shop
Szenario: Kostenloser Versand ab 50 Euro
Angenommen im Warenkorb liegen Artikel für 50,00 €
Wenn ich zur Kasse gehe
Dann betragen die Versandkosten 0,00 €
Szenariogrundriss: Versandkosten nach Bestellwert
Angenommen im Warenkorb liegen Artikel für <wert>
Wenn ich zur Kasse gehe
Dann betragen die Versandkosten <kosten>
Beispiele:
| wert | kosten |
| 49,99 € | 4,90 € |
| 50,00 € | 0,00 € |
✓Gute Gherkin-Szenarien
- Beschreiben Verhalten in Fachsprache, nicht Klicks („Wenn ich zur Kasse gehe“, nicht „Wenn ich auf Button #checkout klicke“).
- Ein Szenario, eine Regel.
- Grenzwerte als Beispieltabelle statt vieler fast gleicher Szenarien.
- Entstehen gemeinsam, etwa in einem kurzen „Three Amigos“-Gespräch von Fachbereich, Entwicklung und Test.
Gherkin im Mittelstand: lohnt sich das?
BDD lohnt sich dort, wo Fachregeln komplex und wertvoll sind: Preisfindung, Förderbedingungen, Tarife, Prüfregeln. Wenn der Fachbereich die Szenarien wirklich liest und mitschreibt, entsteht eine Spezifikation, die nie veraltet. Schreiben nur die Entwickler Gherkin, ist es meist nur ein umständlicher Unit-Test.
Und für alle, die über die Suche hier gelandet sind und etwas anderes meinten: „Gherkin“ heißt auf Englisch auch Gewürzgurke – und so nennen Londoner das Hochhaus 30 St Mary Axe. Daher der Name des Werkzeugs Cucumber.
Wie steht es um die Qualität Deiner Software?
Wir sehen uns Code, Tests und Auslieferung an und zeigen Dir die drei Stellen mit dem größten Risiko – ehrlich, unverbindlich und auf Augenhöhe.
Teil 3 · Qualität im Alltag
Manuell oder automatisiert? Testautomatisierung und CI
| Manuelle Tests | Automatisierte Tests | Exploratives Testen | |
|---|---|---|---|
| Stärke | Menschliches Urteil, Bedienbarkeit, Aussehen | Schnell, wiederholbar, bei jeder Änderung | Findet Unerwartetes |
| Kosten pro Lauf | Hoch, steigt mit jedem Release | Nahe null nach dem Aufbau | Mittel, zeitlich begrenzt |
| Aufbaukosten | Gering | Mittel bis hoch, plus Pflege | Gering, braucht Erfahrung |
| Geeignet für | Einmalige Prüfungen, Abnahme, Usability | Regression, Logik, Schnittstellen, Smoke-Tests | Neue Funktionen, risikoreiche Bereiche |
| Werkzeuge (Beispiele) | Testmanagement, Checklisten | pytest, JUnit, Jest, Playwright, Cypress, Selenium | Session-Notizen, Bildschirmaufnahmen |
Die Frage ist nicht „manuell oder automatisiert“, sondern „was wofür“. Alles, was bei jeder Änderung gleich geprüft werden muss, gehört automatisiert. Alles, was Urteilsvermögen braucht, bleibt beim Menschen.
Ihren vollen Wert entfalten automatisierte Tests in einer Continuous-Integration-Pipeline (CI): Jede Änderung wird automatisch gebaut und getestet, bevor sie in den Hauptzweig darf. Schnelle Tests laufen bei jedem Commit, langsamere nachts oder vor dem Release. So erfährt die Entwicklerin innerhalb von Minuten, ob sie etwas kaputt gemacht hat – nicht drei Wochen später vom Kunden. Wie solche Pipelines aufgebaut werden, zeigt unsere Seite zu DevOps und CI/CD.
Quality Gates
Quality Gates: feste Hürden statt Bauchgefühl
Ein Quality Gate ist eine definierte Prüfstelle, an der eine Änderung messbare Kriterien erfüllen muss, bevor sie weiter darf – etwa vor dem Zusammenführen in den Hauptzweig oder vor dem Deployment. Statt „sieht gut aus“ entscheidet eine nachvollziehbare Regel.
✓Typische Kriterien
- Alle automatisierten Tests grün, keine bekannten Flaky Tests übersprungen
- Mindestabdeckung für neuen und geänderten Code
- Keine neuen kritischen Befunde der statischen Analyse oder des Sicherheitsscans
- Keine bekannten Schwachstellen in Abhängigkeiten
- Mindestens ein Review freigegeben
- Vor dem Release: Smoke-Test in der Zielumgebung bestanden
Clean as you code: Altlasten nicht auf einmal sanieren
Viele Mittelständler haben Software mit zehn oder zwanzig Jahren Geschichte und kaum Tests. Ein Quality Gate, das für den gesamten Bestand 80 % Testabdeckung verlangt, blockiert jede Änderung. Der Ausweg, den etwa die Hersteller statischer Analysewerkzeuge empfehlen: Die Regeln gelten nur für neuen und geänderten Code. Jede Änderung hinterlässt den berührten Bereich etwas besser. Nach einiger Zeit sind gerade die Teile gut abgesichert, die sich am häufigsten ändern.
Wie man Altsysteme darüber hinaus schrittweise erneuert, zeigt unsere Seite zur Software-Modernisierung.
Code Review
Code Review: vier Augen, die sich lohnen
Beim Code Review liest mindestens eine zweite Person die Änderung, bevor sie übernommen wird. Heute fast immer als Pull Request oder Merge Request in GitHub, GitLab, Bitbucket oder Azure DevOps. Reviews finden Fehler, bevor sie laufen – sie sind statisches Testen im besten Sinn – und verteilen Wissen, sodass nicht nur eine Person den Code versteht.
Klein halten
Wenige Hundert Zeilen pro Review. Bei großen Änderungen sinkt die Aufmerksamkeit, und es wird nur noch durchgewunken.
Kontext mitliefern
Was ändert sich, warum, wie getestet? Eine gute Beschreibung spart dem Reviewer die Hälfte der Zeit.
Maschinen prüfen Formales
Formatierung, Stilregeln und bekannte Fehlermuster prüfen Linter und Analysewerkzeuge. Menschen kümmern sich um Logik, Lesbarkeit und Architektur.
Tests gehören dazu
Tests sind auch Code. Der Reviewer prüft, ob die richtigen Fälle getestet sind – nicht nur, ob es Tests gibt.
Schnell antworten
Ein Review, das drei Tage liegt, blockiert. Feste Zeiten im Tagesablauf helfen.
Freundlich und konkret
Fragen statt Urteile, Vorschläge mit Begründung, klare Kennzeichnung von „muss“ und „kann“.
Checkliste nutzen
Fehlerbehandlung, Sicherheit, Datenschutz, Logging, Rückwärtskompatibilität – eine kurze Liste verhindert blinde Flecken.
KI als Vorprüfung
Sprachmodelle können Änderungen zusammenfassen und auf Auffälligkeiten hinweisen. Sie ersetzen das menschliche Review nicht, verkürzen es aber.
Clean Code
Clean Code und Refactoring: Code, den andere ändern können
Code wird viel häufiger gelesen als geschrieben. Clean Code – der Begriff wurde durch das gleichnamige Buch von Robert C. Martin bekannt – meint Code, den eine andere Person schnell versteht und gefahrlos ändern kann. Das ist keine Geschmacksfrage, sondern Wirtschaftlichkeit: Unverständlicher Code macht jede künftige Änderung teurer.
✓Clean-Code-Prinzipien
- Sprechende Namen: berechneVersandkosten statt calc2.
- Eine Aufgabe pro Funktion und kurze Funktionen.
- DRY (Don't Repeat Yourself): Regeln an einer Stelle.
- KISS (Keep It Simple): die einfachste Lösung, die funktioniert.
- YAGNI (You Aren't Gonna Need It): nichts auf Vorrat bauen.
- SOLID: fünf Entwurfsprinzipien, etwa das Open-Closed-Prinzip – offen für Erweiterung, geschlossen für Änderung.
- Pfadfinderregel: Hinterlasse den Code etwas sauberer, als Du ihn vorgefunden hast.
Was ist Refactoring?
Refactoring heißt, die innere Struktur von Code zu verbessern, ohne sein äußeres Verhalten zu ändern. Typische Schritte: Methode extrahieren, Variable umbenennen, Bedingung vereinfachen, Klasse aufteilen, doppelten Code zusammenführen. Martin Fowler hat diese Schritte in seinem Katalog beschrieben; eine bekannte, frei zugängliche Übersicht mit Beispielen bietet die Website Refactoring Guru.
Die wichtigste Regel: Refactoring ohne Tests ist Glücksspiel. Erst Tests, die das heutige Verhalten festhalten, dann umbauen, nach jedem kleinen Schritt testen. Und Refactoring nicht als Großprojekt planen, sondern als Teil jeder Änderung – nach der Pfadfinderregel.
Clean Code hat auch Grenzen: Wer jede Funktion in fünf Einzeiler zerlegt, macht den Code nicht lesbarer. Ziel ist Verständlichkeit, nicht das Abhaken von Regeln.
Technische Schulden
Technische Schulden: der Kredit, den niemand bewilligt hat
Technische Schulden entstehen, wenn ein Team eine schnelle statt einer sauberen Lösung wählt – oder wenn sich die Welt weiterdreht und der Code nicht mit. Wie bei einem Kredit zahlst Du Zinsen: Jede Änderung dauert länger, jeder Fehler wird schwerer zu finden. Laut CISQ summieren sich die technischen Schulden allein in den USA auf rund 1,52 Billionen US-Dollar.
Typische Beispiele: kopierter statt gemeinsam genutzter Code, fehlende Tests, eine veraltete Framework-Version, die keine Sicherheitsupdates mehr bekommt, eine Datenbank ohne klares Modell, Wissen, das nur in einem Kopf steckt. Martin Fowler unterscheidet bewusste und unbewusste, umsichtige und leichtsinnige Schulden. Eine bewusste, umsichtige Schuld – „wir liefern jetzt und räumen im nächsten Sprint auf“ – kann klug sein. Gefährlich sind die, von denen niemand weiß.
Abbauen heißt: Schulden sichtbar machen, etwa in einem eigenen Bereich des Backlogs; einen festen Anteil jeder Iteration fürs Aufräumen reservieren; neue Schulden mit Quality Gates begrenzen; und bei Altsystemen schrittweise modernisieren statt auf den großen Neubau zu warten. Für die Geschäftsführung ist die Übersetzung einfach: Wenn neue Funktionen immer länger dauern, obwohl das Team gleich groß ist, zahlt Ihr Zinsen.
Fehlerbehebung
Debugging und Bugtracking: Fehler finden und verwalten
Debugging heißt, die Ursache eines bekannten Fehlers zu finden und zu beheben. Testen zeigt, dass etwas nicht stimmt; Debugging zeigt, warum. Der Name geht auf eine bekannte Anekdote zurück: 1947 fand das Team um Grace Hopper eine Motte in einem Relais des Rechners Mark II und klebte sie ins Logbuch – der erste „echte Bug“.
✓Systematisch debuggen
- Fehler zuverlässig nachstellen – am besten als automatisierten Test, der rot ist.
- Eingrenzen: Seit welcher Version? Bei welchen Daten? Halbieren statt raten.
- Debugger und Logs nutzen: Haltepunkte setzen, Variablen ansehen, Schritt für Schritt ausführen.
- Ursache beheben, nicht das Symptom.
- Test grün, Regressionstests grün, Erkenntnis festhalten.
Was in einen guten Bug-Report gehört
Ein klarer Titel, die Schritte zum Nachstellen, erwartetes und tatsächliches Ergebnis, Umgebung (Version, Browser, Gerät), Screenshot oder Log und eine Einschätzung der Auswirkung. Mit diesen Angaben spart das Entwicklungsteam oft mehr Zeit als mit der eigentlichen Behebung.
Verwaltet werden Fehler in einem Bugtracker – meist im selben Werkzeug wie die übrigen Aufgaben, etwa Jira, GitHub Issues, GitLab oder Azure Boards. Wichtig ist weniger das Werkzeug als die Regel, wer Fehler bewertet, priorisiert und schließt.
Testmanagement
Testmanagement: Planung, Steuerung und Werkzeuge
Testmanagement sorgt dafür, dass die richtigen Dinge zur richtigen Zeit mit dem richtigen Aufwand getestet werden. In kleinen agilen Teams ist das eine Rolle im Team, in großen oder regulierten Projekten eine eigene Funktion.
Teststrategie und Testkonzept
Welche Risiken gibt es, welche Teststufen und Testarten decken sie ab, was wird automatisiert, wer ist verantwortlich, wann gilt eine Version als freigabefähig? Das Testkonzept hält das für ein Projekt fest.
Testplanung und Steuerung
Welche Tests laufen in welchem Sprint oder vor welchem Release? Testfortschritt, offene Fehler und Restrisiko werden laufend sichtbar gemacht – ehrlich, auch wenn es unbequem ist.
Testmanagement-Werkzeuge
Für manuelle Testfälle und Nachweise, etwa bei Audits, helfen Werkzeuge wie Xray, Zephyr, TestRail oder qTest. Automatisierte Tests leben dagegen im Code-Repository und berichten über die Pipeline.
Ein häufiger Fehler: Testmanagement wird erst kurz vor dem Release eingeschaltet. Dann bleibt nur, Fehler zu zählen. Wirksamer ist es, schon bei den Anforderungen zu fragen, wie man sie testen wird – das ist der Kern von „Shift Left“. Wie agile Teams Testen in ihre Iterationen einbauen, beschreibt unsere Seite zur agilen Softwareentwicklung.
Entscheidungshilfe
Welche Tests braucht Dein Projekt? Vom Risiko zur Teststrategie
Niemand kann alles testen. Beginne deshalb mit der Frage, was im schlimmsten Fall passieren würde – und setze die Tests dort an. Diese Zuordnung hilft beim Einstieg.
Falsche Berechnungen
Preise, Provisionen, Lagerbestände, Abrechnungen. Absicherung: Unit-Tests mit Grenzwerten, BDD-Szenarien mit dem Fachbereich, Regressionstests bei jeder Änderung.
02Ausfall bei hoher Last
Aktionstage im Shop, Monatsabschluss, Saisonspitzen. Absicherung: Last- und Stresstests vor bekannten Spitzen, Monitoring, Smoke-Tests nach jedem Deployment.
03Datenschutzpanne oder Angriff
Kundendaten, Personaldaten, Zugänge. Absicherung: Sicherheitsscans in der Pipeline, Prüfung der Abhängigkeiten, Code Reviews mit Sicherheitscheckliste, Penetrationstest vor dem Go-live.
04Kaputte Schnittstellen
ERP, CRM, Zahlungsanbieter, Lieferanten. Absicherung: Integrationstests gegen Testsysteme, Vertragstests für Schnittstellen, Überwachung im Betrieb. Mehr unter Schnittstellen und API-Entwicklung.
05Nach Updates geht etwas kaputt
Das häufigste Ärgernis in gewachsener Software. Absicherung: automatisierte Regressionstests, Quality Gates für geänderten Code, Pfadfinderregel.
06Nutzer kommen nicht zurecht
Mitarbeiter-Apps, Kundenportale, Verbraucherprodukte. Absicherung: Usability-Tests mit echten Nutzern, Barrierefreiheitsprüfung, exploratives Testen.
Für regulierte Branchen kommen eigene Anforderungen hinzu, etwa Nachweise für Medizinprodukte oder Prüfpflichten im Finanzsektor. Dort gehört die Teststrategie von Anfang an ins Projekt – nicht ans Ende. Wie wir Qualität in unseren eigenen Projekten verankern, liest Du auf der Seite Individuelle Softwareentwicklung.
KI
KI und Softwarequalität: schneller programmieren, gründlicher prüfen
KI-Assistenten schreiben heute in vielen Teams einen großen Teil des Codes. Das beschleunigt – und verschiebt die Arbeit. Der jährliche DORA-Bericht von Google Cloud, eine der größten Studien zur Softwareauslieferung, fand 2024: Mit steigender KI-Nutzung sanken im Schnitt Durchsatz (geschätzt −1,5 %) und Stabilität der Auslieferung (geschätzt −7,2 %) (DORA 2024). Im Bericht 2025 gaben rund 90 % der Befragten an, KI bei der Arbeit zu nutzen, aber etwa 30 % hatten wenig oder kein Vertrauen in KI-generierten Code (DORA 2025).
Die Schlussfolgerung ist nicht „weniger KI“, sondern: Je mehr Code entsteht, desto wichtiger werden die Leitplanken aus diesem Ratgeber. Kleine Änderungen, automatisierte Tests, Quality Gates und Reviews entscheiden, ob KI ein Team schneller macht oder nur schneller Fehler produziert.
KI-Code prüfen
Für KI-generierten Code gelten dieselben Regeln wie für menschlichen: Review, Tests, Quality Gates. Besonders achten auf erfundene Bibliotheken, veraltete Muster, fehlende Fehlerbehandlung und Sicherheitslücken.
KI beim Testen nutzen
KI kann Testfälle aus Anforderungen vorschlagen, Grenzwerte finden, Testdaten erzeugen, Gherkin-Szenarien vorformulieren und Fehlermeldungen zusammenfassen. Ein Mensch prüft, ob die Tests das Richtige prüfen.
KI-Systeme testen
Ein Chatbot oder KI-Agent antwortet nicht immer gleich. Getestet wird mit Bewertungssätzen aus echten Fragen, geprüft werden Richtigkeit, Quellenbezug und Grenzen. Antworten aus verifizierten Dokumenten mit Quellenangabe senken das Risiko erfundener Antworten.
Wie wir Sprachmodelle in bestehende Software einbauen und absichern, beschreiben die Seiten zur KI-Integration und zu KI-Agenten.
Checkliste
Zehn Fragen zur Qualität Deiner Software
Wer diese Fragen mit Ja beantwortet, ist gut aufgestellt. Jedes Nein ist ein Ansatzpunkt.
✓Testen
- Läuft bei jeder Änderung automatisch eine Testsuite?
- Ist die Kernlogik mit Unit-Tests abgesichert?
- Gibt es End-to-End-Tests für die wichtigsten Geschäftsabläufe?
- Dauert die schnelle Testsuite weniger als zehn Minuten?
- Werden Flaky Tests sofort repariert?
✓Qualität im Alltag
- Wird jede Änderung von einer zweiten Person geprüft?
- Gibt es Quality Gates für neuen Code?
- Sind technische Schulden sichtbar und eingeplant?
- Sind alle Abhängigkeiten auf unterstützten Versionen?
- Gibt es Regeln für KI-generierten Code?
Über uns
Qualität als Teil der Entwicklung: wie KI-Helden arbeitet
KI-Helden ist eine Marke der Suchhelden GmbH aus Osnabrück. Seit über einem Jahrzehnt arbeiten wir mit Unternehmen an digitalen Projekten – über 4.000 realisierte Projekte, ein Team aus über 140 Held:innen.
Wenn wir Software entwickeln oder modernisieren, gehören Tests, Reviews und automatische Prüfungen von Anfang an dazu – auch für KI-Funktionen, deren Antworten wir mit Bewertungssätzen prüfen. Die Tests, auch Sicherheits- und Penetrationstests, macht unser Team selbst. So sind zum Beispiel die Lohnabrechnungssoftware Lohnheld mit Steuerberechnung nach amtlichem Programmablaufplan und die KI-Sichtbarkeitsplattform GeoStars entstanden. Mehr zu unseren Leistungen: Softwareentwicklung, Software-Modernisierung, DevOps und CI/CD und App-Entwicklung. Begriffe von A bis Z erklärt unser Glossar, Architekturgrundlagen die Seite Software-Architektur.
Fragen & Antworten
Häufige Fragen zu Software Testing und Softwarequalität
KI-Helden in Osnabrück
Heinrichstraße 14c49080 Osnabrück
- Montag bis Donnerstag
- 08:30–17:00 Uhr
- Freitag
- 08:30–15:00 Uhr
- Samstag und Sonntag
- Geschlossen
Was ist Software Testing einfach erklärt?
Software Testing heißt, ein Programm gezielt auszuführen oder zu prüfen, um herauszufinden, ob es tut, was es soll – und wo nicht. Tests liefern Informationen über Fehler und Risiken. Sie beheben keine Fehler und können nicht beweisen, dass eine Software fehlerfrei ist, aber sie senken das Risiko, dass Fehler erst beim Kunden auffallen.
Welche Arten von Softwaretests gibt es?
Man unterscheidet Teststufen und Testarten. Teststufen sagen, was getestet wird: einzelne Einheiten (Unit-Test), das Zusammenspiel (Integrationstest), das ganze System (Systemtest) und die Abnahme durch Fachbereich oder Kunden. Testarten sagen, welche Eigenschaft geprüft wird: Funktion, Regression, Performance und Last, Sicherheit, Usability und Barrierefreiheit. Dazu kommen Vorgehensweisen wie Black-Box-, White-Box- und exploratives Testen.
Was ist ein Unit-Test?
Ein Unit-Test prüft die kleinste sinnvolle Einheit eines Programms, meist eine Funktion oder Klasse, isoliert von Datenbank, Netzwerk und anderen Systemen. Er läuft automatisch in Millisekunden und meldet sofort, wenn eine Änderung etwas kaputt gemacht hat. Unit-Tests bilden das Fundament der Testpyramide.
Was ist der Unterschied zwischen Gherkin und Cucumber?
Gherkin ist die Sprache, Cucumber ein Werkzeug. In Gherkin beschreibst Du Verhalten in strukturierter Alltagssprache mit Given, When und Then (auf Deutsch Angenommen, Wenn, Dann). Cucumber und vergleichbare Werkzeuge wie SpecFlow oder Behave lesen diese Beschreibungen und führen sie als automatisierte Tests aus.
Was ist der Unterschied zwischen Testen und Qualitätssicherung?
Testen ist ein Teil der Qualitätssicherung. Testen prüft ein Ergebnis und findet Abweichungen. Qualitätssicherung umfasst alles, was Fehler von vornherein verhindert: klare Anforderungen, Code Reviews, Programmierrichtlinien, automatische Prüfungen in der Pipeline und ein Prozess, der aus Fehlern lernt.
Was ist TDD?
TDD steht für Test-Driven Development, testgetriebene Entwicklung. Zuerst schreibst Du einen Test, der fehlschlägt, dann den einfachsten Code, der ihn bestehen lässt, und danach räumst Du den Code auf. Dieser Zyklus heißt Red, Green, Refactor. In Studien bei Microsoft und IBM sank die Fehlerdichte deutlich, die anfängliche Entwicklungszeit stieg etwas.
Was ist ein Regressionstest?
Ein Regressionstest prüft nach einer Änderung, ob bereits funktionierende Teile weiterhin funktionieren. Er schützt vor dem Klassiker: Ein Fehler wird behoben, und an anderer Stelle bricht etwas, das vorher lief. Regressionstests sollten automatisiert sein, weil sie bei jeder Änderung laufen.
Was ist ein Smoke-Test?
Ein Smoke-Test ist ein kurzer Grundcheck nach einem neuen Build oder Deployment: Startet die Anwendung, funktioniert der Login, lädt die Startseite, antwortet die Schnittstelle? Schlägt er fehl, lohnt sich kein weiterer Test. Der Name stammt aus der Hardware: Raucht das Gerät beim Einschalten, braucht man nicht weiterzuprüfen.
Was sind technische Schulden?
Technische Schulden entstehen, wenn ein Team eine schnelle statt einer sauberen Lösung wählt. Wie bei einem Kredit zahlst Du Zinsen: Jede spätere Änderung dauert länger, bis die Schuld durch Aufräumen getilgt ist. In der Stripe-Studie Developer Coefficient gaben Entwickler an, pro Woche 13,5 Stunden mit technischen Schulden zu verbringen.
Was ist ein Code Review?
Bei einem Code Review liest mindestens eine zweite Person geänderten Code, bevor er in den Hauptzweig übernommen wird. Ziel ist, Fehler, Sicherheitslücken und unverständliche Stellen früh zu finden und Wissen im Team zu verteilen. Heute läuft das meist über Pull Requests in GitHub, GitLab oder Bitbucket, oft ergänzt durch KI-gestützte Hinweise.
Was bedeutet Clean Code?
Clean Code bezeichnet Code, den andere schnell verstehen und gefahrlos ändern können: sprechende Namen, kleine Funktionen mit einer Aufgabe, keine Wiederholungen, Tests als Sicherheitsnetz. Bekannt wurde der Begriff durch das gleichnamige Buch von Robert C. Martin. Clean Code ist kein Selbstzweck, sondern senkt die Kosten jeder künftigen Änderung.
Wie viel Testen braucht ein Projekt?
So viel, wie das Risiko verlangt. Eine interne Auswertung für zehn Nutzer braucht weniger als eine Zahlungsabwicklung oder eine Steuerung in der Produktion. Gute Faustregeln: Kernlogik mit Unit-Tests absichern, kritische Abläufe Ende-zu-Ende testen, Regressionstests automatisieren und bei jeder Änderung laufen lassen. Für neuen Code Mindeststandards festlegen, statt alles auf einmal nachzurüsten.
Ersetzt KI das Testen?
Nein. KI kann Testfälle vorschlagen, Testdaten erzeugen und Code Reviews unterstützen. Sie schreibt aber auch selbst Code, der geprüft werden muss. Der DORA-Bericht 2024 von Google fand bei steigender KI-Nutzung eine geringere Stabilität der Auslieferung. Tests, Reviews und automatische Prüfungen werden mit KI also wichtiger, nicht überflüssig.
Wie misst man Softwarequalität?
Über eine Mischung aus Kennzahlen: Fehler, die erst nach dem Release gefunden werden, Fehlerdichte, Testabdeckung des geänderten Codes, Komplexität und Duplikate im Code, Zeit bis zur Behebung eines Fehlers, Ausfallzeiten und Rückmeldungen der Nutzer. Einzelwerte sagen wenig. Aussagekräftig ist der Verlauf über die Zeit.