Black Friday50% OFFGet the deal
← Back to Blog

QA Testing Explained: Process, STLC and Testing Types

By Morgan•Published November 16, 2026•23 min read

QA testing (quality assurance testing) is how a team makes sure software meets its requirements before users get it. It runs across the whole lifecycle: reviewing requirements, planning tests, running manual and automated checks, reporting defects and confirming fixes. QA focuses on preventing defects. Testing finds the ones that slip through.

This guide is for engineers, tech leads and QA engineers who need to set up a QA process, often without a QA team. It covers the six phases of the QA process and what each one leaves behind. It also covers which tests run when, what to automate, and what evidence a manual check should leave.

Each part links to a deeper guide, from writing test cases to reporting defects.

What is QA testing?

QA stands for quality assurance. In software, it is the set of habits that keeps defects out of a release. Think clear requirements, reviews, planned tests and agreed release criteria.

QA testing is the testing work inside that effort. It rests on two ideas that sit side by side.

QA is process focused: it looks at how the team builds software, from the first story to the release. Testing is product focused: it runs the software, or reviews its code and documents, to find defects.

A short way to remember it: QA prevents, testing finds. Good QA does not remove the need to test. It means fewer surprises late in the cycle.

Modern teams also shift left. The ISTQB (International Software Testing Qualifications Board) keeps the standard glossary of testing terms. It defines shift left as doing testing and QA work as early as possible in the lifecycle.

In practice, a tester reads the story before anyone writes code. A developer writes the unit test with the feature, not a week later.

Why QA testing matters

The ISTQB Foundation syllabus (CTFL v4.0.1, section 1.3) lists seven testing principles. Three of them explain why QA testing pays off:

  • Early testing saves time and money. A defect fixed in a requirement never reaches the code built on it.
  • Testing shows that defects are present, not that there are none. A clean run lowers risk. It never proves the build is perfect.
  • Defects cluster together. A few modules usually hold most of the bugs, so test effort should follow them.

There is a human reason too: release confidence. A team that knows what was tested, on which build, can ship without crossing its fingers.

QA vs QC vs testing

People mix up these three terms all the time. The ISTQB glossary keeps them apart.

Quality assurance is the work that builds confidence that quality requirements will be met. Quality control checks how good a given component or system is.

Testing is the process that checks the quality of the product and the work behind it, such as requirements and code. It runs through the whole lifecycle.

TermFocusWhenOutputExample
Quality assurance (QA)The processThe whole lifecycleChecklists and a definition of doneNo story starts without acceptance criteria
Quality control (QC)The productOnce a build existsA pass or fail callChecking a release candidate against exit criteria
TestingThe product and its work productsEarly, then on each changeTest results and bug reportsRunning the regression suite on build 142

The short version: QA shapes the process, QC inspects the result, and testing is the main way software teams inspect. Most people with QA in their job title do all three.

Who does QA testing?

Everyone on the team does some of it. Here is the usual split.

WhoQA work they usually own
DevelopersUnit and integration tests, PR checks, fixing and retesting bugs
QA engineersTest design, exploratory sessions, regression runs, automated tests
Product owner or clientAcceptance: deciding the release does its job
The whole teamA time-boxed bug bash before a big release

A QA tester, or QA engineer, is the specialist in that table. They design the tests, run the risky ones and report what fails.

No QA engineer on your team? The lightweight process later in this guide spreads the same jobs across the people you have.

The QA process: the software testing life cycle (STLC)

The software testing life cycle (STLC) is the sequence of test activities a feature or release moves through. Each phase has an entry condition. Each one also leaves an output that the next phase needs.

That last part is what makes the QA process work. If a phase leaves nothing behind, the next one starts from guesswork.

PhaseWhat happensOutputGuide
1. Requirement analysisCheck each story can be tested, agree acceptance criteria, map stories to testsTestable criteria and a story to test mapAcceptance criteria examples · requirements traceability matrix
2. Test planningSet scope, approach, test setups, risks, entry and exit criteriaA test planTest plan template
3. Test designWrite scenarios, test cases with expected results, and chartersTest cases and chartersTest case template · exploratory testing
4. Environment setupDeploy the build, one account per role, seed data, payments in test modeA ready test setupBug bash (safe test data)
5. Execution and defect reportingSmoke test first, then scripted cases, exploratory sessions and regression; file and retest bugsResults per build, bug reports with evidenceSmoke testing · bug report template
6. Test closureCheck exit criteria, write the summary, record sign-off, publish notesSummary report, sign-off and release notesUAT testing · release notes template
QA testing process diagram showing the six STLC phases in a loop, each with the artifact it leaves behind
QA testing process diagram showing the six STLC phases in a loop, each with the artifact it leaves behind

1. Requirement analysis

Testing starts before code. The tester, or the developer who will test, reads each story and asks one question: how would I know this passes? Vague words like "fast" or "easy" become numbers and examples.

The output is a set of testable criteria and a map from each requirement to its tests. Good acceptance criteria examples read like small test cases. Atlassian's guide to acceptance criteria shows how to write them, with three worked examples.

Larger teams, or teams under audit, keep the map as a requirements traceability matrix. Testers also read the PRD to spot needs nobody can test yet.

2. Test planning

Planning decides what you will test, how and where. The plan names what is in and out of scope and the approach for each risk. It also lists the test setups and the entry and exit criteria.

The QA lead or tech lead owns it. For one feature it fits on a page, and a test plan template keeps it that short.

3. Test design

Design turns criteria into tests. Testers write scenarios, test cases with exact expected results, and charters for exploratory sessions.

Two techniques from the ISTQB syllabus keep the number of cases small. Equivalence partitioning picks one test per group of inputs the system treats the same way. Boundary value analysis tests the edges, where developers slip most often.

The boundary value example for email and password rules shows both at work.

4. Environment setup

Tests need a stable place to run. Deploy the build to a test or staging environment and write down its build number. Each result will cite it.

Create one account per role, seed realistic fake data and put payments and email in test mode. The bug bash guide shows how to seed test data that is safe to screenshot.

5. Execution and defect reporting

Run a smoke test first. If login or checkout is broken, stop and send the build back.

Then run the scripted cases, the exploratory sessions and the regression suite. Log each result against the build number.

File each failure with steps, expected and actual results, and evidence. Retest it on the build that holds the fix.

6. Test closure

Closure answers one question: can we ship? Check the exit criteria and list open defects with their risk. Then write a short summary: what was tested, on which build, with what result.

For big releases, the product owner or client records acceptance. Then you publish release notes.

Keep the test cases and evidence too. Test docs are documentation, and the same rules apply as in good technical documentation examples.

STLC vs the ISTQB test process

The six phases above are industry shorthand. The ISTQB Foundation syllabus (CTFL v4.0.1, section 1.4.1) describes seven groups of test activities instead:

  1. Test planning
  2. Test monitoring and test control
  3. Test analysis
  4. Test design
  5. Test implementation
  6. Test execution
  7. Test completion

The two lists map closely. Requirement analysis is test analysis, environment setup is part of test implementation, and closure is test completion. Monitoring and control (tracking progress against the plan) runs through all of them.

The syllabus also notes that these activities "are often implemented iteratively or in parallel". So treat both lists as a loop, not a one-way waterfall.

The STLC in Agile teams

In Agile, the loop runs per story. Criteria get agreed in refinement, and tests get designed and automated during the sprint. Execution happens before the story closes.

Release-level work does not go away, though. Before each release you still run regression across the product. You also get acceptance for flows that span many stories.

Types of QA testing: levels, types and approaches

Most lists of QA testing types mix up three questions. How much of the system is under test, what does the test check, and how is it run?

The ISTQB syllabus (section 2.2) separates the first two:

  • Five test levels: component (unit), component integration, system, system integration and acceptance.
  • Four test types: functional, non-functional, black-box and white-box.
  • Two change-related types: confirmation testing and regression testing.

This guide adds one practical split of its own: how a check is run, scripted or exploratory, manual or automated. ISTQB files exploratory testing under experience-based techniques, not as a level or a type.

TypeWhat it checksWhen it runsUsually run by
Unit (component)One function or class aloneEach commit and PRDevelopers
Integration (component integration)How parts work togetherEach PRDevelopers
SystemThe whole product against its specOn a test buildQA
System integrationLinks to outside services and APIsOn stagingQA
End-to-endA full user journeyNightly and before releaseQA or CI
AcceptanceFit with the business needBefore releaseProduct owner or users
FunctionalWhat the system doesAt each levelEveryone
PerformanceSpeed under loadBefore big launchesQA
SecurityWeak spots an attacker could useEach release and on a scheduleSecurity team
UsabilityHow easily people finish tasksOn prototypes and stagingUX researchers
AccessibilityKeyboard, screen reader, contrastEach feature and releaseQA or designers
CompatibilityBrowsers, devices, OS versionsEach releaseQA
SmokeWhether a build is worth testingAfter each deployQA or CI
RegressionThat nothing that worked brokeEach merge, in full before releaseCI and QA
ExploratoryWhat nobody wrote downEach feature, in timed sessionsQA and developers
Timeline of which QA tests run at pull request, merge, staging deploy, release candidate and production deploy
Timeline of which QA tests run at pull request, merge, staging deploy, release candidate and production deploy

Checks that decide if a build is worth testing

A smoke test runs a handful of critical paths right after a deploy: log in, load the main page, save a record. If one fails, the build goes back before anyone spends a day on it. After a fix, a narrow re-check of the changed area (often called a sanity check) confirms it before deeper testing starts.

Checks that confirm requirements

Functional testing checks what the system does against its requirements. System tests run those checks on the whole product. End-to-end tests follow one user journey through each layer, from the UI to the database.

Each starts as a test case with an exact expected result. The split between functional vs non-functional requirements decides which checks a story needs.

Checks that find what nobody wrote down

Scripted cases only find the bugs someone predicted. In exploratory testing, a tester designs and runs tests at the same time, guided by a charter and a time box.

A bug bash scales the same idea to the whole team for an hour or two. Both catch the odd edge cases that specs miss.

Checks that prove nothing broke

Regression testing checks that a change did not break the parts you did not touch. It runs on each change, which makes it the first suite most teams automate. Confirmation testing is the rerun after a fix, to prove the failure is gone.

Visual regression testing compares screenshots with a baseline to catch layout breaks. This visual testing checklist adds responsive and localized layout checks and CI review gates.

Checks on how well it works

Non-functional testing checks how well the system behaves, not what it does. Performance tests measure speed under load.

Security tests look for weak spots an attacker could use. Usability tests watch real people try real tasks.

Accessibility tests cover keyboard use, screen readers and contrast against WCAG, with a color contrast check for text. Compatibility tests cover browsers, devices and OS versions.

Checks that accept the release

Acceptance testing asks whether the release meets the business need, not only the spec. In user acceptance testing (UAT), business users or the client run real scenarios and sign off.

Alpha testing puts the build in front of potential users in a controlled setting. Beta testing then hands it to real customers for real-world feedback.

Black box vs white box testing

Black-box testing designs tests from the spec: inputs, outputs and behavior, with no look at the code. White-box testing designs them from the internal structure, such as code paths, branches and data flows.

Most manual QA work is black box. Developers write white-box unit tests to cover the code they own.

ScreenSnap Pro
From the makers of this site

Tired of plain screenshots? Try ScreenSnap Pro.

Beautiful backgrounds, pro annotations, GIF recording, and instant cloud sharing, all in one app. Pay $39 once, own it forever.

See pricing and features

Manual testing vs automation testing

In manual testing, a person runs the check and judges the result. In automated testing, a script runs it and asserts the result.

The ISTQB glossary keeps both definitions short. Manual testing is a test activity done by hand. Test automation turns test activities into automated ones.

Neither one wins. They answer different questions.

A script can confirm that a total is $72.00 a thousand times a day. Only a person notices that the coupon field is hard to find.

AutomateKeep manual
Unit and API checksExploratory sessions
Smoke checks after each deployUI that changes every sprint
Regression suitesUsability and accessibility judgement (keyboard, screen reader)
Visual baselines (visual regression testing)One-off checks
Data-driven cases: one test, many inputsUAT

The test pyramid

The test pyramid is a model of how much testing each level gets: the lower the level, the more tests. In practice that means many fast unit tests, fewer integration tests and only a few slow UI tests.

Ham Vocke's The Practical Test Pyramid explains it in depth. The idea comes from Mike Cohn's book Succeeding with Agile, and the ISTQB syllabus covers it too (section 5.1.6).

Test pyramid with unit, integration and UI layers and a side band of non-functional QA testing checks
Test pyramid with unit, integration and UI layers and a side band of non-functional QA testing checks

A good rule of thumb: automate a check when it runs each release, gives the same result each time and sits on UI that rarely changes. If it fails any of the three, keep it manual for now.

For browser automation, the Playwright screenshot guide and the Selenium screenshot guide show how to capture evidence inside test scripts. Still picking a framework? Read Puppeteer vs Playwright.

QA testing tools by category

You need one tool per category, not the "best" tool in each. Most teams already own half of them.

CategoryWhat it doesExamples
Test managementStores cases, plans runs, logs resultsA test tool, or a shared sheet
Test frameworksRun unit, API and UI checks in CIPlaywright, Selenium, Cypress
API testingSends requests and checks the repliesPostman
Bug trackingLogs, assigns and tracks bugsJira, GitHub Issues and other bug reporting tools
Capture and markupScreenshots, recordings and notes on themOS built-ins or a capture app (see the evidence section)

Where AI fits

AI tools now draft test cases, suggest edge cases and repair broken locators when the UI changes. People still review that output. They own the risk calls: what to test, what to skip and when a build is good enough to ship.

A lightweight QA process for teams without testers

No QA engineer? You can still run a real QA process. These six steps spread the work across developers and the product owner:

  1. Acceptance criteria on every story. No criteria, no work. Write them as examples someone could check, like good acceptance criteria examples do.
  2. Unit and integration tests in every PR. CI blocks the merge if they fail. Add a "How to test" section to your pull request template so reviewers can repeat the check.
  3. A smoke test after every deploy, on staging and again on production. 10 to 15 checks, under 5 minutes automated or 10 to 15 minutes by hand.
  4. A 45 to 60 minute exploratory session per big feature, run by someone who did not build it.
  5. One bug format with evidence. Everyone files the same fields with the same kind of screenshot, based on one bug report template.
  6. Stakeholder sign-off for big releases through a short UAT round, then release notes that say what changed.

The format matters more than the tool. Agree on one evidence format for the whole team. Use counter markers that match the written steps, one arrow with a short callout, and a solid box over secrets.

A QA checklist for one feature

Paste this into the story, PR or ticket. Tick it off before the story closes.

**QA checklist: [story ID] [feature name]**

- [ ] Acceptance criteria reviewed and testable
- [ ] Unit and integration tests added, CI green
- [ ] Smoke check updated for the new path
- [ ] Exploratory session done, notes linked
- [ ] Bugs filed with steps, expected vs actual and evidence
- [ ] Regression run passed on build: ______
- [ ] Docs and release notes updated
- [ ] Sign-off recorded (who and when)
Filled QA checklist for a coupon feature with eight ticked items, a build number and a bug ID with its evidence file
Filled QA checklist for a coupon feature with eight ticked items, a build number and a bug ID with its evidence file

Note the build number on the regression line and the evidence file on the bug line. Those two details answer most questions a lead will ask later.

Three process mistakes to avoid

  • Testing starts after the code is done. By then, a vague requirement has turned into a wrong feature. Bring a tester, or a second developer, in before coding starts.
  • Results carry no build number. "It passed" means little if nobody knows which build passed. Each result and each bug should name the build and where it ran.
  • Bugs filed as "it does not work". No steps, no expected result, no evidence. The developer has to track down the reporter. The next section fixes this one.

How to capture evidence during manual QA

Good evidence lets a developer reproduce a failure without a call. It also lets a lead see what passed without asking.

Automated checks leave logs on their own. Manual checks leave only what the tester captures.

Test activityWhat to captureGuide
Smoke check failsScreenshot, console log, build and setupSmoke testing
Test case step failsExpected vs actual callout, step numbers from the caseTest case template
Exploratory sessionNumbered screenshots plus session notesExploratory testing
Flow or timing bugA 10 to 20 second recording (mic optional) or a silent GIFGIF capture on Mac · Windows
Long page behind a loginOne long screenshot: select the content, scroll down by hand, let the tool stitch itScrolling screenshots on Mac · Windows
Error text in a toastCopy the text with OCR into the ticketCopy text on Mac · OCR on Windows
UAT failureA screenshot tied to the script stepUAT testing
Bug bash findingThe 60 second filing cardBug bash

Five evidence rules for screenshots

  1. Capture the region, not the desktop. Crop to what failed, plus the build number if it shows.
  2. Number the steps so the counters match the written steps. See how to annotate screenshots on a Mac or edit screenshots on Windows.
  3. Use one arrow and one short callout, such as "Expected $72.00 · got $80.00".
  4. Cover secrets with a solid box. Tokens, passwords and customer data get an opaque box, because blur and pixelate can be reversed. Seeded test data is safer still.
  5. Attach the file to the ticket or test run, as with screenshots in Jira or a GitHub issue template. A share link is a quick heads-up, never the record.
Annotated staging checkout bug with numbered steps, an Expected $72.00 · got $80.00 callout and a boxed test email
Annotated staging checkout bug with numbered steps, an Expected $72.00 · got $80.00 callout and a boxed test email

For recordings, trim the clip to the failure and list the step numbers in the ticket, or say them over the mic. A state bug like the one below is clearer in motion: the name changes, the form shows unsaved changes, and Save never turns on.

Animated capture of a profile form where the Save button stays disabled after the display name changes
Animated capture of a profile form where the Save button stays disabled after the display name changes

For web apps, see how to annotate a website. Write the team's evidence policy (file names, where files live, what counts as a pass) in your test plan template.

No markup tool installed? The free image annotation tool adds solid boxes, arrows and text in the browser. The extract text from image tool copies error text out of a screenshot.

Your OS covers the basics too. On a Mac, Shift + Command + 4 captures a region. Shift + Command + 5 opens the Screenshot toolbar, which also records the screen (Apple's guide).

Markup in Preview adds arrows, shapes and text. Live Text copies text from an image on macOS Monterey or later.

On Windows 11, Snipping Tool captures with Win + Shift + S, records with Win + Shift + R and copies text with Text actions. It has no scrolling capture, so a long page takes several shots.

Any capture tool can follow these rules. When evidence is a daily job, ScreenSnap Pro (Mac and Windows) keeps the routine in one app. The counter tool numbers steps, arrows and callouts mark expected vs actual, and a filled rectangle covers secrets.

Its Scrolling Capture grabs a long page behind a login: select the area, click Start Capture, scroll down by hand, then click Finish. For timing bugs, record the screen with mic narration, trim the clip in the built-in editor and export an MP4 or a silent GIF.

Frequently Asked Questions

Start with one feature next sprint

Pick one feature in your next sprint and run it through the six phases with the checklist above. Write the criteria first, smoke test each deploy and file each failure with the same evidence format. Once the loop works for one feature, it works for a release.

Capturing test evidence all day? ScreenSnap Pro puts region capture, numbered counters, solid-box redaction, Scrolling Capture and screen recording in one app.

It is a one-time $39 purchase: 1 license, 2 seats (2 computers, Mac or Windows). See pricing.

Author
Morgan

Morgan

Indie Developer

Indie developer, founder of ScreenSnap Pro. A decade of shipping consumer Mac apps and developer tools. Read full bio

@m_0_r_g_a_n_