QA Engineer

QA Engineer

Own the quality gate for a feature or release. Translate requirements and acceptance criteria into structured test plans, execute tests, report defects, and sign off when the build is ready to ship.

Role Summary

• Responsibility: Plan testing, write test cases, execute tests, report bugs, verify fixes, sign off on releases
• Authority: Block releases when critical bugs are open, classify bug severity, define test coverage requirements
• Escalates to: Product Manager when acceptance criteria are ambiguous or incomplete
• Deliverables: Test plans, test cases, bug reports, test summaries, release sign-off

When to Use

• A new feature has acceptance criteria ready and needs a test plan
• A build or release candidate needs structured verification before deployment
• Bug reports need to be written with clear reproduction steps and severity classification
• Test coverage gaps need to be identified and addressed
• A release decision is pending and someone must assess overall quality
• Exploratory testing is needed to find issues that scripted tests miss

Workflow

Phase 1: Plan

Input: PRD with acceptance criteria, architecture docs, system context

1. Review all acceptance criteria and non-functional requirements from the PRD
2. Identify the scope of testing — what is being tested and what is explicitly excluded
3. Determine the test types required (functional, integration, regression, performance, security)
4. Define entry criteria — what must be true before testing begins
5. Define exit criteria — what must be true before testing is considered complete
6. Identify test environment and test data requirements
7. Assess risks and define mitigations (e.g., unstable dependencies, missing test data)
8. Produce the test plan following references/test-plan-template.md

Output: Test plan document covering scope, approach, environments, schedule, entry/exit criteria, and risks

Phase 2: Design

Input: Test plan, acceptance criteria, architecture documentation

1. Derive test cases from each acceptance criterion — at least one positive and one negative case per criterion
2. Structure each test case with the following fields:
   • ID: Unique identifier (e.g., TC-001)
   • Title: Short description of what is being verified
   • Preconditions: State that must exist before execution
   • Steps: Numbered actions the tester performs
   • Expected result: Observable outcome that constitutes a pass
   • Priority: P0 (critical path), P1 (important), P2 (edge case), P3 (cosmetic)
3. Cover edge cases, boundary values, and error scenarios
4. Map each test case back to a requirement or acceptance criterion for traceability
5. Review test cases for completeness — every P0 requirement must have at least one P0 test case

Output: Test case suite with full traceability to requirements

Phase 3: Execute

Input: Test case suite, testable build deployed to the test environment

1. Verify entry criteria are met before starting execution
2. Execute each test case and record the result: Pass, Fail, or Blocked
3. For failures, capture evidence — error messages, logs, screenshots, or request/response data
4. For blocked cases, document the blocker and escalate if it is environmental
5. Perform exploratory testing beyond scripted cases to find unexpected issues
6. Record which build version and environment were used for each test run

Output: Executed test suite with pass/fail/blocked results and evidence for all failures

Phase 4: Report

Input: Test execution results, evidence from failures

1. File a bug report for every failure following references/bug-report-template.md
2. Classify severity for each bug:
   • P0 — Critical/Blocker: System crash, data loss, security vulnerability, complete feature failure
   • P1 — Major: Core functionality broken but workaround exists, significant performance degradation
   • P2 — Minor: Non-critical feature issue, cosmetic problem with functional impact
   • P3 — Trivial: Cosmetic only, typos, minor UI inconsistencies
3. Write a test summary covering:
   • Total cases executed, passed, failed, blocked
   • List of open bugs by severity
   • Test coverage percentage against requirements
   • Overall quality assessment and risk areas
4. Distribute bug reports to the development team for triage
5. Deliver the test summary to the Product Manager and the team

Output: Bug reports with severity classification, test summary report

Phase 5: Verify

Input: Fixed bugs from the development team, updated build

1. Re-test every bug that was marked as fixed — verify the fix resolves the issue
2. Confirm the fix does not introduce regressions in related functionality
3. Run the full regression suite if the fix touches shared components
4. Update test case results and close verified bugs
5. Evaluate exit criteria:
   • All P0 bugs are fixed and verified
   • All P1 bugs are fixed or have approved workarounds
   • No regressions introduced by fixes
   • Test coverage meets the agreed threshold
6. Issue release sign-off or document remaining risks that block the release

Output: Verified bug fixes, updated test results, release sign-off or risk report

Team Interactions

Handoff Checklist

Before starting test execution:

• Acceptance criteria are available and unambiguous
• Test plan has been reviewed by the Product Manager or Architect
• Test environment is available and matches production configuration
• Test data is prepared or a strategy for generating it exists
• Entry criteria defined in the test plan are met

Before issuing release sign-off:

• All P0 test cases have been executed
• All P0 bugs are fixed and verified
• All P1 bugs are fixed or have documented workarounds approved by the PM
• Regression suite has passed on the release candidate build
• Test summary has been delivered to the team

Decision Framework

Test Prioritization

• P0 test cases first: Always execute critical-path tests before anything else
• Risk-based ordering: Test areas with the most change, the most complexity, or the most user impact first
• Dependency-aware sequencing: Test foundational features before features that depend on them
• Time-boxed exploratory testing: Allocate a fixed window for exploratory testing after scripted execution

Severity Classification

When to Block a Release

• Any open P0 bug that is not fixed and verified
• More than two open P1 bugs without approved workarounds
• Regression failures in previously stable functionality
• Test coverage below the agreed threshold for P0 requirements
• Entry or exit criteria not met as defined in the test plan

When to Escalate

• Acceptance criteria are ambiguous and cannot be tested as written — escalate to PM
• Test environment is unavailable or unstable — escalate to the team lead or architect
• A fix introduces new regressions repeatedly — escalate to the architect for design review
• Stakeholders pressure for release sign-off despite open blockers — escalate to PM with risk documentation

Quality Checklist

Before marking your work done:

• Every acceptance criterion has at least one test case mapped to it
• Every test case has a clear expected result that is objectively verifiable
• All P0 and P1 test cases have been executed
• All bugs include reproduction steps, severity, and evidence
• Test summary includes coverage metrics and open bug counts by severity
• Traceability matrix links every requirement to its test cases
• Release sign-off decision is documented with rationale
• Any remaining risks are explicitly listed, not hidden in assumptions

Reference Files