A test plan written after development is complete is not a test plan — it is a test that proves what was built, not whether what was built is correct. QA testing starts when the design starts, not when the build is finished.
Quality assurance testing is often treated as a phase that happens after the product or feature is built — a quality gate that approves what already exists. But the most valuable QA testing is the testing that shapes what gets built: acceptance criteria defined alongside requirements, test cases written from the specification (not from the implementation), and test environments prepared in parallel with development so testing can begin the moment the build is complete. The rule of ten applies equally in software and physical products: a defect found during design costs a unit of effort; found during build it costs ten; found by the customer it costs a hundred. Structured QA testing is the mechanism that shifts defect discovery as early in the lifecycle as possible. This free checklist gives QA engineers, test managers, quality managers, and product teams a structured framework for the full QA testing process — from test planning through to test sign-off.
QA Testing Across Two Domains — Common Principles, Different Test Types
Software / Digital Products
Functional testing: Does it do what the specification says?
Regression testing: Did the change break anything that previously worked?
Integration testing: Do the components work correctly together?
Performance testing: Does it respond within acceptable time under expected load?
Security testing: Are there exploitable vulnerabilities?
UAT: Can real users complete their key tasks?
Accessibility testing: Is it usable by people with disabilities?
Test tools: Test management platforms (Jira, TestRail), automated frameworks (Selenium, Cypress, Playwright), API testing tools (Postman), performance tools (JMeter, k6).
Physical / Manufactured Products
Functional/performance testing: Does the product perform to its specification under normal conditions?
Environmental testing: Does it operate across its specified temperature, humidity, and altitude range?
Durability/life testing: Does it maintain performance over its specified service life?
Safety testing: Does it meet the relevant safety standards for its market?
Regulatory/certification testing: CE, UL, FCC, FDA, etc.
Packaging/shipping testing: Does the product survive its supply chain?
Test tools: Physical test equipment, environmental chambers, measurement instruments, third-party certification labs.
Common Principles (Both Domains)
Test cases written from the specification — not the implementation
Test environments representative of real-world conditions
Defects logged, triaged, and tracked through to verified resolution
Test results documented with evidence
Go/No-Go sign-off based on defined criteria established before testing starts
The QA Testing Checklist
Six phases covering the full test lifecycle — from test planning and test case development through environment setup, execution, defect management, and formal sign-off.
Phase 1
Phase 1: Test Planning & Strategy
The test plan is developed from the requirements or specification — ideally in parallel with the design phase, not after the build is complete. A test plan written after the build is a test plan at risk of being shaped by what was built rather than what was required.
Define the test scope — what is being tested; what is explicitly out of scope; what testing was done at earlier stages that this test phase builds on
Define test objectives and success criteria — what does “pass” look like? The Go/No-Go criteria defined now, before testing begins
Select test types — based on the risk profile of the product/feature; which test types are required? Functional, regression, integration, performance, security, UAT (software); functional, environmental, durability, certification (physical)
Identify test resources — who will conduct each test type; what equipment, tools, and environments are required; availability confirmed
Estimate the testing timeline — realistic time for each test type; factored into the project schedule before development starts
Phase 2
Phase 2: Test Case Development
Write test cases from the specification — not from the implementation; each test case has: a reference to the requirement it tests; a precondition; the test steps; the expected result; and the pass/fail criterion
Cover positive and negative cases — test that the product does what it should (positive) AND that it handles incorrect inputs, boundary conditions, and error scenarios correctly (negative)
Review test cases — with the product owner or design engineer; confirm every requirement is covered by at least one test case
Confirm traceability — every requirement maps to at least one test case; no requirement goes untested (unacceptable for safety-critical or compliance requirements)
Phase 3
Phase 3: Test Environment Setup
Software test environment — representative of production; separate from development and production; test data prepared; all required integrations configured
Physical test equipment — calibrated; available for the test dates; any environmental test chambers or specialist equipment booked in advance
Test data prepared (software) — representative of real-world data volumes and types; including edge-case data; compliant with data privacy requirements (anonymised where required)
Reference samples prepared (physical) — approved samples or golden units for comparison
Phase 4
Phase 4: Test Execution
Execute functional tests — following each test case; recording actual result against expected result; pass or fail for each
Execute regression tests — to confirm the change has not broken previously-passing functionality; automated regression suite where available
Execute integration tests — confirming interfaces between components, systems, or subsystems work correctly together
Execute performance tests — response times under expected load (software); output performance under rated conditions (physical); confirmed against specification
Execute edge case and negative tests — boundary values, invalid inputs, error conditions; do they produce the expected controlled failure or error response?
Execute UAT (software) or regulatory/certification tests (physical) — by real users (UAT) or by a certified test lab (regulatory testing)
Log every defect found — following the defect classification and logging process; every test case that produces an unexpected result generates a defect report
Phase 5
Phase 5: Defect Management During Testing
Triage all defects — severity and priority assigned; duplicates identified and linked; confirmed as defects (not misunderstood requirements)
Critical/Major defects block testing progression — until resolved; the test cycle does not complete until all Critical and Major defects are resolved and re-tested
Retest all fixed defects — by the tester who found the original defect (where possible); following the original test steps; confirming the fix is effective and has not introduced regressions
Phase 6
Phase 6: Test Sign-Off & Entry to Next Phase
The test sign-off is a formal, criteria-based decision — not a judgment call made under schedule pressure. The criteria are the same ones defined in Phase 1. If the criteria are not met, the product does not advance to the next phase.
Assess against the Go/No-Go criteria — defined in Phase 1; all required test types completed, all test cases executed, no Critical or Major defects open
Produce the test summary report — total test cases executed, pass rate, defects by severity, open defects, and the sign-off recommendation
Obtain sign-off — from the QA lead and the product owner or engineering lead; written confirmation that the product meets the test criteria and is ready to advance
Archive all test artefacts — test plan, test cases, test results, defect records, and sign-off document; in the product or project record
Test Coverage — Ensuring Every Requirement Is Tested
A test coverage matrix (also called a requirements traceability matrix) maps every requirement in the specification to one or more test cases. Its purpose is to ensure that every requirement — especially safety-critical and compliance requirements — is verified by at least one test case before the product or feature is approved. Without a coverage matrix, test gaps are invisible: the team may believe the product has been thoroughly tested when entire requirements have not been verified.
Building the coverage matrix is straightforward: list all requirements (numbered), list all test cases (referenced), and map each test case to the requirement(s) it verifies. Requirements with no test case mapped to them represent a coverage gap. Test cases with no requirement mapped to them may be testing something not in scope — or may represent requirements that were implemented without being formally documented. For regulated products (medical devices, automotive safety systems, aerospace components), the coverage matrix is not optional — it is a regulatory submission requirement.
Why Run Your QA Testing Process in CheckFlow?
1
Test cases executed against the specification — with a documented result for each
A test that was “run” but not recorded — where the only evidence is the tester’s memory — is not a completed test. CheckFlow records a pass/fail result against every test case, with the tester’s name and a timestamp, building the test evidence record that sign-off requires.
2
Defects tracked through testing to verified resolution
The defect logged during testing that is not tracked through to retest — because it was “fixed” but the fix was not verified — is the defect that ships to the customer. CheckFlow’s defect management phase tracks every defect from detection through retest confirmation, and prevents test sign-off while Critical or Major defects remain open.
3
A recurring testing process for continuous delivery teams
Software teams that release frequently need a testing cycle that runs on the same cadence. CheckFlow’s recurring feature schedules the QA testing workflow automatically at each release cycle — ensuring the full test process is completed before every release, not just for major versions.
QA testing produces defects that require structured management. CheckFlow’s Defect Reporting & Resolution Checklist covers the manufacturing defect process; for software bugs, see the Bug Tracking & Resolution Checklist in the Product Development & Launch series. See the Defect Reporting & Resolution Checklist →
Software QA testing is a prerequisite for every feature release. CheckFlow’s Feature Release Process Checklist in the Product Development & Launch series covers the full deployment workflow where QA sign-off is a required gate. See the Feature Release Process Checklist →
A QA testing checklist covers six phases: test planning (scope, success criteria/Go-No-Go definition, test types selected, resources and timeline), test case development (written from specification, positive and negative cases, edge cases, peer review, traceability confirmed), test environment setup (representative environment, calibrated equipment, test data), test execution (all test types executed, results recorded against each test case, defects logged), defect management during testing (triage, Critical/Major defects block progression, retest of fixes), and test sign-off (Go/No-Go criteria assessment, test summary report, written sign-off, test artefact archiving).
What is the difference between functional testing and regression testing?
+
Functional testing verifies that a product or feature does what the specification says it should — it tests the new or changed functionality against its requirements. Regression testing verifies that changes made to the product (bug fixes, new features, configuration changes) have not broken functionality that was previously working correctly. Both are essential: functional testing confirms the new work is correct; regression testing confirms the existing work remains correct. Regression testing is the primary reason software teams invest in test automation — manually re-testing all existing functionality after every change is not scalable in a continuous delivery environment.
What does QA testing for physical products involve?
+
QA testing for physical products typically involves: functional/performance testing (verifying the product performs to its specification under normal operating conditions), environmental testing (verifying performance across the specified temperature, humidity, altitude, and vibration range), durability and reliability testing (accelerated life testing, HALT/HASS, or operational endurance testing to verify the product meets its service life specification), safety testing (verifying the product meets relevant safety standards — electrical safety, mechanical safety, flammability, chemical safety depending on the product and market), regulatory and certification testing (CE marking in Europe, UL in the US, FCC for radio-frequency products, FDA for medical devices), and packaging and shipping testing (verifying the product survives its supply chain packaging and shipping conditions).
What is a test coverage matrix?
+
A test coverage matrix (or requirements traceability matrix, RTM) is a document that maps every requirement in the product or feature specification to one or more test cases, and maps every test case back to the requirement it verifies. Its purpose is to ensure that every requirement is tested at least once and that no requirement is shipped without verification. Requirements that have no test case mapped to them represent a test coverage gap that should be resolved before sign-off. Test cases with no requirement mapped to them represent either undocumented requirements or out-of-scope testing.
Is CheckFlow free for this template?
+
You can start a free 14-day trial with no credit card required, giving you full access to all features including this template. The Business plan is $10 per user per month after the trial. Full details at checkflow.io/pricing.
Test Every Requirement, Log Every Defect, and Sign Off on Evidence — Not Optimism
Free trial — no credit card required.
Do you like cookies? 🍪 We use cookies to ensure you get the best experience on our website. Learn more