QA-Testing erklärt: Prozess, STLC und Testarten
QA-Testing (Quality Assurance Testing, also Testen im Rahmen der Qualitätssicherung) ist die Art und Weise, wie ein Team sicherstellt, dass Software ihre Anforderungen erfüllt, bevor Nutzer sie bekommen. Es zieht sich durch den gesamten Lebenszyklus: Anforderungen prüfen, Tests planen, manuelle und automatisierte Checks ausführen, Fehler melden und Fixes bestätigen. QA konzentriert sich darauf, Fehler zu verhindern. Das Testen findet die, die trotzdem durchrutschen.
Dieser Leitfaden ist für Entwickler, Tech Leads und QA Engineers, die einen QA-Prozess aufsetzen müssen, oft ohne eigenes QA-Team. Er behandelt die sechs Phasen des QA-Prozesses und was jede davon hinterlässt. Außerdem erfährst du, welche Tests wann laufen, was du automatisieren solltest und welche Nachweise ein manueller Check hinterlassen sollte.
Jeder Teil verlinkt auf einen ausführlicheren Leitfaden, vom Schreiben von Testfällen bis zum Melden von Fehlern.
Was ist QA-Testing?
QA steht für Quality Assurance, also Qualitätssicherung. In der Softwareentwicklung sind das die Gewohnheiten, die Fehler aus einem Release heraushalten. Denk an klare Anforderungen, Reviews, geplante Tests und vereinbarte Release-Kriterien.
QA-Testing ist die Testarbeit innerhalb der Qualitätssicherung. Dahinter stehen zwei Ideen, die nebeneinander bestehen.
QA ist prozessorientiert: Sie betrachtet, wie das Team Software baut, von der ersten Story bis zum Release. Testen ist produktorientiert: Es führt die Software aus oder prüft ihren Code und ihre Dokumente, um Fehler zu finden.
Als Merksatz: QA verhindert, Testen findet. Gute QA macht Tests nicht überflüssig. Sie sorgt für weniger Überraschungen spät im Zyklus.
Moderne Teams setzen außerdem auf Shift-Left. Das ISTQB (International Software Testing Qualifications Board) pflegt das Standardglossar der Testbegriffe. Es definiert Shift-Left als Ansatz, Test- und QA-Aktivitäten so früh wie möglich im Lebenszyklus auszuführen.
In der Praxis liest ein Tester die Story, bevor jemand Code schreibt. Ein Entwickler schreibt den Unit-Test zusammen mit dem Feature, nicht eine Woche später.
Warum QA-Testing wichtig ist
Der ISTQB-Foundation-Lehrplan (CTFL v4.0.1, Abschnitt 1.3) nennt sieben Grundsätze des Testens. Drei davon erklären, warum sich QA-Testing auszahlt:
- Frühes Testen spart Zeit und Geld. Ein Fehler, der schon in der Anforderung behoben wird, landet nie im Code, der darauf aufbaut.
- Testen zeigt die Anwesenheit von Fehlern, nicht ihre Abwesenheit. Ein sauberer Lauf senkt das Risiko. Er beweist nie, dass der Build perfekt ist.
- Fehler treten gehäuft auf. Wenige Module enthalten meist die meisten Bugs, also sollte der Testaufwand ihnen folgen.
Es gibt auch einen menschlichen Grund: Vertrauen ins Release. Ein Team, das weiß, was auf welchem Build getestet wurde, kann ausliefern, ohne die Daumen zu drücken.
QA vs. QC vs. Testen
Diese drei Begriffe werden ständig verwechselt. Das ISTQB-Glossar hält sie auseinander.
Qualitätssicherung ist die Arbeit, die Vertrauen schafft, dass die Qualitätsanforderungen erfüllt werden. Die Qualitätskontrolle (im deutschen ISTQB-Glossar Qualitätssteuerung) prüft, wie gut eine bestimmte Komponente oder ein System ist.
Testen ist der Prozess, der die Qualität des Produkts und der Arbeit dahinter bewertet, etwa von Anforderungen und Code. Es zieht sich durch den gesamten Lebenszyklus.
| Begriff | Fokus | Wann | Ergebnis | Beispiel |
|---|---|---|---|---|
| Qualitätssicherung (QA) | Der Prozess | Der gesamte Lebenszyklus | Checklisten und eine Definition of Done | Keine Story startet ohne Akzeptanzkriterien |
| Qualitätskontrolle (QC) | Das Produkt | Sobald es einen Build gibt | Eine Entscheidung: bestanden oder nicht bestanden | Einen Release Candidate gegen die Endekriterien prüfen |
| Testen | Das Produkt und seine Arbeitsergebnisse | Früh, dann bei jeder Änderung | Testergebnisse und Bug-Reports | Die Regressionssuite auf Build 142 ausführen |
Kurz gesagt: QA gestaltet den Prozess, QC prüft das Ergebnis, und Testen ist die wichtigste Methode, mit der Softwareteams prüfen. Die meisten Leute mit QA im Jobtitel übernehmen alle drei Aufgaben.
Wer macht QA-Testing?
Jeder im Team übernimmt einen Teil davon. So sieht die übliche Aufteilung aus.
| Wer | Typische QA-Aufgaben |
|---|---|
| Entwickler | Unit- und Integrationstests, PR-Checks, Bugs fixen und nachtesten |
| QA Engineers | Testentwurf, explorative Sessions, Regressionsläufe, automatisierte Tests |
| Product Owner oder Kunde | Abnahme: entscheiden, ob das Release seinen Zweck erfüllt |
| Das ganze Team | Ein Bug Bash mit fester Timebox vor einem großen Release |
Ein QA-Tester oder QA Engineer ist der Spezialist in dieser Tabelle. Er entwirft die Tests, führt die riskanten selbst aus und meldet, was fehlschlägt.
Kein QA Engineer in deinem Team? Der schlanke Prozess weiter unten in diesem Leitfaden verteilt dieselben Aufgaben auf die Leute, die du hast.
Der QA-Prozess: der Softwaretest-Lebenszyklus (STLC)
Der Software Testing Life Cycle (STLC), also der Lebenszyklus des Softwaretests, ist die Abfolge von Testaktivitäten, die ein Feature oder Release durchläuft. Jede Phase hat eine Eingangsbedingung. Und jede hinterlässt ein Ergebnis, das die nächste Phase braucht.
Genau dieser letzte Punkt bringt den QA-Prozess zum Laufen. Wenn eine Phase nichts hinterlässt, beginnt die nächste mit Rätselraten.
| Phase | Was passiert | Ergebnis | Leitfaden |
|---|---|---|---|
| 1. Anforderungsanalyse | Prüfen, ob jede Story testbar ist, Akzeptanzkriterien vereinbaren, Stories den Tests zuordnen | Testbare Kriterien und eine Zuordnung von Stories zu Tests | Beispiele für Akzeptanzkriterien · Requirements Traceability Matrix |
| 2. Testplanung | Umfang, Vorgehen, Testumgebungen, Risiken, Eingangs- und Endekriterien festlegen | Ein Testplan | Testplan-Vorlage |
| 3. Testentwurf | Szenarien, Testfälle mit erwarteten Ergebnissen und Charters schreiben | Testfälle und Charters | Testfall-Vorlage · Exploratives Testen |
| 4. Aufbau der Testumgebung | Build deployen, ein Konto pro Rolle, Testdaten einspielen, Zahlungen im Testmodus | Eine einsatzbereite Testumgebung | Bug Bash (sichere Testdaten) |
| 5. Durchführung und Fehlermeldung | Zuerst ein Smoke-Test, dann geskriptete Testfälle, explorative Sessions und Regression; Bugs melden und nachtesten | Ergebnisse pro Build, Bug-Reports mit Nachweisen | Smoke-Testing · Bug-Report-Vorlage |
| 6. Testabschluss | Endekriterien prüfen, Zusammenfassung schreiben, Abnahme festhalten, Release Notes veröffentlichen | Abschlussbericht, Abnahme und Release Notes | UAT-Test · Release-Notes-Vorlage |

1. Anforderungsanalyse
Testen beginnt vor dem Code. Der Tester (oder der Entwickler, der testen wird) liest jede Story und stellt eine Frage: Woran würde ich erkennen, dass die Story besteht? Vage Wörter wie „schnell“ oder „einfach“ werden zu Zahlen und Beispielen.
Das Ergebnis sind testbare Kriterien und eine Zuordnung jeder Anforderung zu ihren Tests. Gute Beispiele für Akzeptanzkriterien lesen sich wie kleine Testfälle. Der Atlassian-Leitfaden zu Akzeptanzkriterien zeigt, wie du sie schreibst, mit drei durchgespielten Beispielen.
Größere Teams oder Teams, die Audits unterliegen, führen die Zuordnung als Requirements Traceability Matrix (Anforderungs-Rückverfolgbarkeitsmatrix). Tester lesen außerdem das PRD (Produktanforderungsdokument), um Anforderungen zu entdecken, die noch niemand testen kann.
2. Testplanung
Bei der Planung entscheidest du, was du testest, wie und wo. Der Plan nennt, was im Umfang liegt und was nicht, und das Vorgehen für jedes Risiko. Außerdem listet er die Testumgebungen sowie die Eingangs- und Endekriterien auf.
Verantwortlich ist der QA-Lead oder Tech Lead. Für ein einzelnes Feature passt der Plan auf eine Seite, und eine Testplan-Vorlage hält ihn so kurz.
3. Testentwurf
Beim Entwurf werden aus Kriterien Tests. Tester schreiben Szenarien, Testfälle mit exakten erwarteten Ergebnissen und Charters für explorative Sessions.
Zwei Techniken aus dem ISTQB-Lehrplan halten die Zahl der Testfälle klein. Die Äquivalenzklassenbildung wählt einen Test pro Gruppe von Eingaben, die das System gleich behandelt. Die Grenzwertanalyse testet die Ränder, an denen Entwicklern die meisten Fehler unterlaufen.
Das Grenzwert-Beispiel für E-Mail- und Passwortregeln zeigt beide in Aktion.
4. Aufbau der Testumgebung
Tests brauchen einen stabilen Ort, an dem sie laufen. Deploye den Build in eine Test- oder Staging-Umgebung und notier dir seine Build-Nummer. Jedes Ergebnis wird sich darauf beziehen.
Leg ein Konto pro Rolle an, spiel realistische Fake-Daten ein und schalte Zahlungen und E-Mails in den Testmodus. Der Bug-Bash-Leitfaden zeigt, wie du Testdaten anlegst, die gefahrlos auf Screenshots landen dürfen.
5. Durchführung und Fehlermeldung
Führ zuerst einen Smoke-Test durch. Wenn Login oder Checkout kaputt sind, hör auf und schick den Build zurück.
Danach führst du die geskripteten Testfälle, die explorativen Sessions und die Regressionssuite aus. Halte jedes Ergebnis zusammen mit der Build-Nummer fest.
Melde jeden Fehlschlag mit Schritten, erwartetem und tatsächlichem Ergebnis sowie Nachweisen. Teste ihn auf dem Build erneut, der den Fix enthält.
6. Testabschluss
Der Abschluss beantwortet eine Frage: Können wir ausliefern? Prüf die Endekriterien und liste offene Fehler mit ihrem Risiko auf. Schreib dann eine kurze Zusammenfassung: was getestet wurde, auf welchem Build und mit welchem Ergebnis.
Bei großen Releases hält der Product Owner oder der Kunde die Abnahme fest. Danach veröffentlichst du die Release Notes.
Bewahr auch die Testfälle und Nachweise auf. Testunterlagen sind Dokumentation, und es gelten dieselben Regeln wie bei guten Beispielen für technische Dokumentation.
STLC vs. ISTQB-Testprozess
Die sechs Phasen oben sind eine Kurzform aus der Praxis. Der ISTQB-Foundation-Lehrplan (CTFL v4.0.1, Abschnitt 1.4.1) beschreibt stattdessen sieben Gruppen von Testaktivitäten:
- Testplanung
- Testüberwachung und Teststeuerung
- Testanalyse
- Testentwurf
- Testrealisierung
- Testdurchführung
- Testabschluss
Die beiden Listen entsprechen sich weitgehend. Die Anforderungsanalyse entspricht der Testanalyse, der Aufbau der Testumgebung gehört zur Testrealisierung, und der Testabschluss ist in beiden Listen derselbe Schritt. Testüberwachung und Teststeuerung (den Fortschritt mit dem Plan abgleichen) ziehen sich durch alle Aktivitäten.
Der Lehrplan weist außerdem darauf hin, dass diese Aktivitäten oft iterativ oder parallel umgesetzt werden. Behandle beide Listen also als Schleife, nicht als Wasserfall in eine Richtung.
Der STLC in agilen Teams
In Agile läuft die Schleife pro Story. Die Kriterien werden im Refinement vereinbart, und die Tests werden während des Sprints entworfen und automatisiert. Die Durchführung passiert, bevor die Story geschlossen wird.
Die Arbeit auf Release-Ebene fällt dadurch aber nicht weg. Vor jedem Release führst du trotzdem Regressionstests über das ganze Produkt aus. Außerdem holst du die Abnahme für Abläufe ein, die sich über viele Stories erstrecken.
Arten von QA-Tests: Teststufen, Testarten und Vorgehensweisen
Die meisten Listen mit QA-Testarten vermischen drei Fragen: Wie viel vom System wird getestet, was prüft der Test, und wie wird er ausgeführt?
Der ISTQB-Lehrplan (Abschnitt 2.2) trennt die ersten beiden:
- Fünf Teststufen: Komponententest (Unit), Komponentenintegrationstest, Systemtest, Systemintegrationstest und Abnahmetest.
- Vier Testarten: funktionaler Test, nicht-funktionaler Test, Black-Box-Test und White-Box-Test.
- Zwei änderungsbezogene Arten: Fehlernachtest und Regressionstest.
Dieser Leitfaden ergänzt eine eigene, praktische Unterscheidung: wie ein Check ausgeführt wird, geskriptet oder explorativ, manuell oder automatisiert. Das ISTQB ordnet exploratives Testen den erfahrungsbasierten Testverfahren zu, nicht den Teststufen oder Testarten.
| Test | Was er prüft | Wann er läuft | Meist durchgeführt von |
|---|---|---|---|
| Unit-Test (Komponententest) | Eine einzelne Funktion oder Klasse isoliert | Bei jedem Commit und PR | Entwickler |
| Integrationstest (Komponentenintegrationstest) | Wie Teile zusammenarbeiten | Bei jedem PR | Entwickler |
| Systemtest | Das ganze Produkt gegen seine Spezifikation | Auf einem Test-Build | QA |
| Systemintegrationstest | Anbindungen an externe Dienste und APIs | Auf Staging | QA |
| End-to-End-Test | Eine komplette User Journey | Nächtlich und vor dem Release | QA oder CI |
| Abnahmetest | Ob es den fachlichen Bedarf erfüllt | Vor dem Release | Product Owner oder Nutzer |
| Funktionaler Test | Was das System tut | Auf jeder Teststufe | Alle |
| Performancetest | Geschwindigkeit unter Last | Vor großen Launches | QA |
| Sicherheitstest | Schwachstellen, die ein Angreifer ausnutzen könnte | Bei jedem Release und regelmäßig nach Plan | Security-Team |
| Usability-Test | Wie leicht Menschen Aufgaben erledigen | An Prototypen und auf Staging | UX Researcher |
| Barrierefreiheitstest | Tastatur, Screenreader, Kontrast | Bei jedem Feature und Release | QA oder Designer |
| Kompatibilitätstest | Browser, Geräte, Betriebssystemversionen | Bei jedem Release | QA |
| Smoke-Test | Ob ein Build das Testen wert ist | Nach jedem Deployment | QA oder CI |
| Regressionstest | Dass nichts kaputtging, was vorher funktioniert hat | Bei jedem Merge, komplett vor dem Release | CI und QA |
| Explorativer Test | Was niemand aufgeschrieben hat | Bei jedem Feature, in Sessions mit Timebox | QA und Entwickler |

Checks, ob ein Build das Testen wert ist
Ein Smoke-Test prüft direkt nach einem Deployment eine Handvoll kritischer Pfade: anmelden, die Hauptseite laden, einen Datensatz speichern. Schlägt einer fehl, geht der Build zurück, bevor jemand einen Tag damit verbringt. Nach einem Fix bestätigt ein eng begrenzter Check des geänderten Bereichs (oft Sanity-Test genannt) die Korrektur, bevor tiefere Tests starten.
Checks, die Anforderungen bestätigen
Funktionale Tests prüfen, was das System tut, gemessen an seinen Anforderungen. Systemtests führen diese Prüfungen am ganzen Produkt aus. End-to-End-Tests folgen einer User Journey durch jede Schicht, von der Oberfläche bis zur Datenbank.
Jeder davon beginnt als Testfall mit einem exakten erwarteten Ergebnis. Die Unterscheidung zwischen funktionalen und nicht-funktionalen Anforderungen entscheidet, welche Checks eine Story braucht.
Checks, die finden, was niemand aufgeschrieben hat
Geskriptete Testfälle finden nur die Bugs, die jemand vorhergesehen hat. Beim explorativen Testen entwirft ein Tester Tests und führt sie gleichzeitig aus, geleitet von einer Charter und einer Timebox.
Ein Bug Bash überträgt dieselbe Idee für ein, zwei Stunden auf das ganze Team. Beide fangen die seltsamen Randfälle ein, die Spezifikationen übersehen.
Checks, die beweisen, dass nichts kaputtgegangen ist
Regressionstests prüfen, dass eine Änderung die Teile nicht kaputtgemacht hat, die du nicht angefasst hast. Sie laufen bei jeder Änderung, deshalb automatisieren die meisten Teams ihre Regressionssuite als Erstes. Der Fehlernachtest (Confirmation Testing) ist die Wiederholung nach einem Fix, die beweist, dass der Fehler weg ist.
Visual Regression Testing vergleicht Screenshots mit einer Baseline, um Layoutfehler zu erkennen. Eine Checkliste für visuelle Tests in Webteams ergänzt Checks für responsive und lokalisierte Layouts sowie Review-Gates in der CI.
Checks, wie gut es funktioniert
Nicht-funktionale Tests prüfen, wie gut sich das System verhält, nicht was es tut. Performancetests messen die Geschwindigkeit unter Last.
Sicherheitstests suchen nach Schwachstellen, die ein Angreifer ausnutzen könnte. Usability-Tests beobachten echte Menschen bei echten Aufgaben.
Barrierefreiheitstests decken Tastaturbedienung, Screenreader und Kontrast nach WCAG ab, mit einer Prüfung des Farbkontrasts für Text. Kompatibilitätstests decken Browser, Geräte und Betriebssystemversionen ab.
Checks, die das Release abnehmen
Der Abnahmetest fragt, ob das Release den fachlichen Bedarf erfüllt, nicht nur die Spezifikation. Beim User Acceptance Test (UAT) spielen Fachanwender oder der Kunde echte Szenarien durch und erteilen die Abnahme.
Beim Alphatest bekommen potenzielle Nutzer den Build in einer kontrollierten Umgebung zu sehen. Der Betatest gibt ihn dann an echte Kunden weiter, um Feedback aus der Praxis zu bekommen.
Black-Box- vs. White-Box-Test
Beim Black-Box-Test entstehen die Tests aus der Spezifikation: Eingaben, Ausgaben und Verhalten, ohne Blick in den Code. Beim White-Box-Test entstehen sie aus der internen Struktur, etwa aus Codepfaden, Verzweigungen und Datenflüssen.
Die meiste manuelle QA-Arbeit ist Black-Box-Testen. Entwickler schreiben White-Box-Unit-Tests, um den Code abzudecken, für den sie verantwortlich sind.
Manuelles Testen vs. Testautomatisierung
Beim manuellen Testen führt ein Mensch den Check aus und beurteilt das Ergebnis. Beim automatisierten Testen führt ein Skript ihn aus und prüft das Ergebnis per Assertion.
Das ISTQB-Glossar hält beide Definitionen kurz. Ein manueller Test ist eine Testaktivität, die von Hand ausgeführt wird. Testautomatisierung stellt Testaktivitäten auf automatischen Betrieb um.
Keins von beiden gewinnt. Sie beantworten unterschiedliche Fragen.
Ein Skript kann tausendmal am Tag bestätigen, dass eine Summe $72.00 beträgt. Nur ein Mensch merkt, dass das Gutscheinfeld schwer zu finden ist.
| Automatisieren | Manuell lassen |
|---|---|
| Unit- und API-Checks | Explorative Sessions |
| Smoke-Checks nach jedem Deployment | Oberflächen, die sich in jedem Sprint ändern |
| Regressionssuiten | Urteil über Usability und Barrierefreiheit (Tastatur, Screenreader) |
| Visuelle Baselines (Visual Regression Testing) | Einmalige Checks |
| Datengetriebene Testfälle: ein Test, viele Eingaben | UAT |
Die Testpyramide
Die Testpyramide ist ein Modell dafür, wie viel Testaufwand jede Stufe bekommt: Je tiefer die Stufe, desto mehr Tests. In der Praxis heißt das: viele schnelle Unit-Tests, weniger Integrationstests und nur wenige langsame UI-Tests.
Ham Vockes Artikel The Practical Test Pyramid (auf Englisch) erklärt sie ausführlich. Die Idee stammt aus Mike Cohns Buch Succeeding with Agile, und auch der ISTQB-Lehrplan behandelt sie (Abschnitt 5.1.6).

Eine gute Faustregel: Automatisiere einen Check, wenn er bei jedem Release läuft, jedes Mal dasselbe Ergebnis liefert und eine Oberfläche prüft, die sich selten ändert. Wenn eine der drei Bedingungen nicht zutrifft, bleib vorerst beim manuellen Check.
Für die Browser-Automatisierung zeigen der Playwright-Screenshot-Leitfaden und der Selenium-Screenshot-Leitfaden, wie du Nachweise direkt in Testskripten aufnimmst. Du suchst noch ein Framework? Lies Puppeteer vs. Playwright.
Tools für QA-Testing nach Kategorie
Du brauchst ein Tool pro Kategorie, nicht das „beste“ Tool in jeder. Die meisten Teams haben die Hälfte davon schon.
| Kategorie | Aufgabe | Beispiele |
|---|---|---|
| Testmanagement | Testfälle speichern, Läufe planen, Ergebnisse protokollieren | Ein Testtool oder eine gemeinsame Tabelle |
| Test-Frameworks | Unit-, API- und UI-Checks in der CI ausführen | Playwright, Selenium, Cypress |
| API-Tests | Requests senden und die Antworten prüfen | Postman |
| Bugtracking | Bugs erfassen, zuweisen und verfolgen | Jira, GitHub Issues und andere Bug-Reporting-Tools |
| Aufnahme und Markierung | Screenshots, Aufnahmen und Notizen darauf | Bordmittel des Betriebssystems oder ein Aufnahme-Tool (siehe den Abschnitt zu Nachweisen) |
Wo KI ins Spiel kommt
KI-Tools entwerfen heute Testfälle, schlagen Randfälle vor und reparieren kaputte Locators, wenn sich die Oberfläche ändert. Menschen prüfen diese Ergebnisse trotzdem. Sie treffen die Risikoentscheidungen: was getestet wird, was nicht und wann ein Build gut genug zum Ausliefern ist.
Genug von langweiligen Screenshots? Probier ScreenSnap Pro.
Schöne Hintergründe, professionelle Anmerkungen, GIF-Aufnahme und sofortiges Teilen in der Cloud, alles in einer App. Einmal 39 $ zahlen, für immer besitzen.
Preis und Funktionen ansehenEin schlanker QA-Prozess für Teams ohne Tester
Kein QA Engineer? Du kannst trotzdem einen echten QA-Prozess fahren. Diese sechs Schritte verteilen die Arbeit auf Entwickler und Product Owner:
- Akzeptanzkriterien für jede Story. Keine Kriterien, keine Arbeit. Schreib sie als Beispiele, die jemand prüfen kann, so wie es gute Beispiele für Akzeptanzkriterien tun.
- Unit- und Integrationstests in jedem PR. Die CI blockiert den Merge, wenn sie fehlschlagen. Ergänze dein Pull-Request-Template um einen Abschnitt „Testanleitung“, damit Reviewer den Check wiederholen können.
- Ein Smoke-Test nach jedem Deployment, auf Staging und noch einmal in Produktion. 10 bis 15 Checks, automatisiert in unter 5 Minuten, von Hand in 10 bis 15 Minuten.
- Eine explorative Session von 45 bis 60 Minuten pro großem Feature, durchgeführt von jemandem, der es nicht gebaut hat.
- Ein Bug-Format mit Nachweisen. Alle füllen dieselben Felder mit derselben Art von Screenshot aus, auf Basis einer gemeinsamen Bug-Report-Vorlage.
- Abnahme durch die Stakeholder bei großen Releases über eine kurze UAT-Runde, danach Release Notes, die sagen, was sich geändert hat.
Das Format ist wichtiger als das Tool. Leg ein Nachweisformat für das ganze Team fest. Nutze Zählermarker, die zu den geschriebenen Schritten passen, einen Pfeil mit kurzem Callout und einen deckenden Kasten über Secrets.
Eine QA-Checkliste für ein Feature
Füg sie in die Story, den PR oder das Ticket ein. Hak sie ab, bevor die Story geschlossen wird.
**QA-Checkliste: [Story-ID] [Feature-Name]**
- [ ] Akzeptanzkriterien geprüft und testbar
- [ ] Unit- und Integrationstests ergänzt, CI grün
- [ ] Smoke-Check für den neuen Pfad aktualisiert
- [ ] Explorative Session durchgeführt, Notizen verlinkt
- [ ] Bugs mit Schritten, erwartet vs. tatsächlich und Nachweisen gemeldet
- [ ] Regressionslauf bestanden auf Build: ______
- [ ] Doku und Release Notes aktualisiert
- [ ] Abnahme festgehalten (wer und wann)
Achte auf die Build-Nummer in der Zeile zur Regression und auf die Nachweisdatei in der Zeile zu den Bugs. Diese zwei Details beantworten die meisten Fragen, die ein Lead später stellt.
Drei Prozessfehler, die du vermeiden solltest
- Das Testen beginnt erst, wenn der Code fertig ist. Bis dahin ist aus einer vagen Anforderung ein falsches Feature geworden. Hol einen Tester oder einen zweiten Entwickler dazu, bevor das Coden beginnt.
- Ergebnisse ohne Build-Nummer. „Hat bestanden“ heißt wenig, wenn niemand weiß, welcher Build bestanden hat. Jedes Ergebnis und jeder Bug sollte den Build nennen und sagen, wo er lief.
- Bugs, gemeldet als „geht nicht“. Keine Schritte, kein erwartetes Ergebnis, kein Nachweis. Der Entwickler muss erst die meldende Person aufspüren. Der nächste Abschnitt behebt genau das.
So sicherst du Nachweise bei manuellen QA-Tests
Mit guten Nachweisen kann ein Entwickler einen Fehlschlag ohne Call reproduzieren. Und ein Lead sieht, was bestanden hat, ohne nachfragen zu müssen.
Automatisierte Checks hinterlassen von selbst Logs. Manuelle Checks hinterlassen nur das, was der Tester festhält.
| Testaktivität | Was du festhältst | Leitfaden |
|---|---|---|
| Smoke-Check schlägt fehl | Screenshot, Konsolenlog, Build und Umgebung | Smoke-Testing |
| Schritt eines Testfalls schlägt fehl | Callout mit erwartet vs. tatsächlich, Schrittnummern aus dem Testfall | Testfall-Vorlage |
| Explorative Session | Nummerierte Screenshots plus Session-Notizen | Exploratives Testen |
| Bug in einem Ablauf oder beim Timing | Eine Aufnahme von 10 bis 20 Sekunden (Mikrofon optional) oder ein GIF ohne Ton | GIF-Aufnahme auf dem Mac · unter Windows |
| Lange Seite hinter einem Login | Ein langer Screenshot: Inhalt auswählen, von Hand nach unten scrollen, das Tool fügt alles zusammen | Scrollende Screenshots auf dem Mac · unter Windows |
| Fehlertext in einer Toast-Meldung | Den Text per OCR ins Ticket kopieren | Text kopieren auf dem Mac · OCR unter Windows |
| Fehlschlag im UAT | Ein Screenshot, der dem Skriptschritt zugeordnet ist | UAT-Test |
| Fund aus dem Bug Bash | Die 60-Sekunden-Meldekarte | Bug Bash |
Fünf Regeln für Screenshots als Nachweis
- Nimm den Bereich auf, nicht den ganzen Desktop. Schneide auf das zu, was fehlgeschlagen ist, plus die Build-Nummer, falls sie zu sehen ist.
- Nummeriere die Schritte, damit die Zähler zu den geschriebenen Schritten passen. Sieh dir an, wie du Screenshots auf dem Mac annotierst oder Screenshots unter Windows bearbeitest.
- Nutze einen Pfeil und ein kurzes Callout, etwa „Erwartet $72.00 · erhalten $80.00“.
- Verdeck Secrets mit einem deckenden Kasten. Tokens, Passwörter und Kundendaten bekommen einen undurchsichtigen Kasten, denn Weichzeichnen und Verpixeln lassen sich rückgängig machen. Eingespielte Testdaten sind noch sicherer.
- Häng die Datei an das Ticket oder den Testlauf an, so wie bei Screenshots in Jira oder einem GitHub Issue Template. Ein Share-Link ist ein schneller Hinweis, nie der eigentliche Nachweis.

Bei Aufnahmen kürzt du den Clip auf den Fehlschlag und listest die Schrittnummern im Ticket auf oder sprichst sie über das Mikrofon ein. Ein Zustandsfehler wie der unten ist in Bewegung klarer: Der Name ändert sich, das Formular zeigt ungespeicherte Änderungen an, und Save wird nie aktiv.

Für Web-Apps zeigt dir ein eigener Leitfaden, wie du eine Website annotierst. Halte die Nachweisregeln des Teams (Dateinamen, Ablageort, was als bestanden gilt) in deiner Testplan-Vorlage fest.
Kein Markup-Tool installiert? Das kostenlose Tool zur Bildannotation fügt im Browser deckende Kästen, Pfeile und Text hinzu. Das Tool zum Extrahieren von Text aus Bildern kopiert Fehlertexte aus einem Screenshot.
Auch dein Betriebssystem deckt die Grundlagen ab. Auf dem Mac nimmt Shift + Command + 4 einen Bereich auf. Shift + Command + 5 öffnet die Werkzeugleiste der Bildschirmfoto-App, mit der du auch Videos vom Bildschirm aufnimmst (Anleitung von Apple).
Mit den Markierungswerkzeugen der Vorschau fügst du Pfeile, Formen und Text hinzu. Live Text kopiert ab macOS Monterey Text aus einem Bild.
Unter Windows 11 nimmt das Snipping Tool mit Win + Shift + S Screenshots auf, mit Win + Shift + R Videos und kopiert mit den Textaktionen Text. Eine scrollende Aufnahme hat es nicht, also brauchst du für eine lange Seite mehrere Aufnahmen.
Diese Regeln funktionieren mit jedem Aufnahme-Tool. Wenn Nachweise zu deinem Arbeitsalltag gehören, bündelt ScreenSnap Pro (Mac und Windows) die Routine in einer App. Das Zähler-Werkzeug nummeriert Schritte, Pfeile und Callouts markieren erwartet vs. tatsächlich, und ein gefülltes Rechteck deckt Secrets ab.
Mit der Scrolling Capture der App nimmst du eine lange Seite hinter einem Login auf: Bereich auswählen, auf Start Capture klicken, von Hand nach unten scrollen und dann auf Finish klicken. Bei Timing-Bugs nimmst du den Bildschirm mit Kommentar über das Mikrofon auf, kürzt den Clip im integrierten Editor und exportierst ein MP4 oder ein GIF ohne Ton.
Häufig gestellte Fragen
Was ist ein QA-Tester?
Ein QA-Tester, oft auch QA Engineer genannt, prüft, ob Software funktioniert, bevor Nutzer sie bekommen. Er prüft Anforderungen, entwirft Tests und führt sie aus, meldet Fehler mit Nachweisen, testet Fixes erneut und schreibt oft automatisierte Tests. In Teams ohne QA-Tester teilen sich Entwickler und Product Owner diese Aufgaben.
Was ist ein White-Box-Test?
Beim White-Box-Test entstehen die Tests aus dem Inneren der Software: aus ihrem Code, ihren Verzweigungen, Pfaden und Datenflüssen. Der Tester sieht den Code und will dessen Struktur abdecken, deshalb schreiben meist Entwickler diese Tests als Unit-Tests. Der Black-Box-Test ist das Gegenteil, denn er arbeitet nur mit der Spezifikation.
Werden QA-Tester durch KI ersetzt?
Unwahrscheinlich: KI-Tools können Testfälle entwerfen, Randfälle vorschlagen und kaputte Locators reparieren, was viel Routinearbeit spart. Sie können aber nicht entscheiden, was deinen Nutzern wichtig ist, Risiken bewerten oder merken, dass sich ein Ablauf falsch anfühlt. Menschen prüfen weiterhin, was die KI erzeugt, und entscheiden, ob ein Build bereit ist.
Was sind die 7 Phasen des Softwaretests?
Mit den sieben Phasen sind meist die Testaktivitäten des ISTQB gemeint: Testplanung, Testüberwachung und Teststeuerung, Testanalyse, Testentwurf, Testrealisierung, Testdurchführung und Testabschluss. Viele Teams nutzen stattdessen den STLC mit sechs Phasen. Der Abschnitt oben zu STLC vs. ISTQB-Testprozess ordnet die eine Liste der anderen zu.
Was genau ist QA-Testing?
QA steht für Quality Assurance, also Qualitätssicherung, und QA-Testing ist die Testarbeit, die dazugehört. Es prüft durch Reviews, geplante Tests, manuelle und automatisierte Checks und Fehlerberichte, ob Software ihre Anforderungen erfüllt. Die Antwort ganz oben in diesem Leitfaden und der Abschnitt QA vs. QC erklären, wie es sich von der Qualitätskontrolle unterscheidet.
Ist QA dasselbe wie Testen?
Nicht ganz: QA ist der umfassendere Prozess, der Fehler verhindern soll, von Reviews der Anforderungen bis zu den Release-Kriterien. Testen ist eine Aktivität darin: das Produkt ausführen oder seine Dokumente und seinen Code prüfen, um Fehler zu finden. Leute mit QA im Jobtitel machen beides, deshalb werden die beiden Begriffe oft verwechselt.
Fang im nächsten Sprint mit einem Feature an
Such dir ein Feature aus deinem nächsten Sprint aus und schick es mit der Checkliste oben durch die sechs Phasen. Schreib zuerst die Kriterien, mach nach jedem Deployment einen Smoke-Test und melde jeden Fehlschlag im selben Nachweisformat. Sobald die Schleife für ein Feature funktioniert, funktioniert sie auch für ein Release.
Du sicherst den ganzen Tag Testnachweise? ScreenSnap Pro vereint Bereichsaufnahme, nummerierte Zähler, Schwärzen mit deckenden Kästen, Scrolling Capture und Bildschirmaufnahme in einer App.
Es ist ein einmaliger Kauf für 39 $: 1 Lizenz für 2 Computer (2 Aktivierungen, Mac oder Windows). Zu den Preisen.
Morgan
Indie DeveloperIndie developer, founder of ScreenSnap Pro. A decade of shipping consumer Mac apps and developer tools. Read full bio
@m_0_r_g_a_n_

