Quality Engineer (QC / QA / Tester)

Mission

Own quality across the whole build, from code to product. At EmeSoft, QC, QA, and Tester are one role - the Quality Engineer. They guard quality at the code level (review, standards, security gates) and validate the increment against requirements (functional, regression, E2E) before it is accepted.

One role, two complementary jobs

This role covers both questions:

• “Are we building it right?” - code review, standards, static analysis, security gates (the classic QC job).
• “Did we build the right thing, and does it work?” - functional, regression, and end-to-end testing against acceptance criteria (the classic QA/Test job).

Combining them gives one owner accountable for quality from pull request to sign-off, with no gap between code review and product validation.

Responsibilities

Code quality (QC side)

• Maintain and enforce automated quality gates (linting, static analysis, coverage).
• Run and triage security scanning (SAST, dependency/SCA, secrets).
• Uphold the Definition of Done at the code level.

Product quality (QA/Test side)

• Design test cases and a test plan from acceptance criteria (starting at refinement).
• Build and maintain automated tests: functional, regression, E2E, API.
• Run exploratory testing for cases automation won’t catch.
• Validate non-functional aspects with the Architect (performance, security, accessibility).
• Report and triage defects, verify fixes, and sign off that the increment meets acceptance criteria.

Inputs

Input	From
Pull requests	Developers
Coding, quality & security standards	Architect/Dev Lead
Stories & acceptance criteria	Business Analyst / Stakeholders
Test environments & data	Architect / DevOps
Non-functional requirements	Architect, Stakeholders

Outputs

Output	To
Review feedback / approvals	Developers
Quality & security gate results	Team, Architect
Test plan, cases & automated suites	Team, CI
Defect reports & triage	Developers
Test results & increment sign-off	Stakeholders (via PM/BA)

AI tools & how we use them

This role uses AI across both review and testing - as a tireless first-pass reviewer and as a test generator.

On the QC side

• SAST + AI triage (Snyk, SonarQube, GitHub Advanced Security): scan for vulnerabilities; AI explains findings, proposes fixes, and ranks true vs false positives.
• Dependency / SCA & license checks (Dependabot, Snyk): flag vulnerable or non-compliant packages automatically.

On the QA/Test side

• AI test-case generation (Claude / ChatGPT): generate a test matrix - happy path, boundary, error, security - directly from acceptance criteria. Prompt: “From these acceptance criteria, generate a test matrix covering happy path, boundary, error, and security cases.”
• AI test automation (Copilot, Cursor, Playwright/Selenium codegen): generate and maintain UI/API test scripts; self-healing locators cut flaky-test maintenance. See AI-Augmented QA Automation for the full Playwright-based approach - how the suite grows on greenfield and existing projects and lets CI assess quality anytime.
• AI API testing (Postman AI): generate request collections and assertions from an API spec.
• AI defect triage: cluster failures, deduplicate, and suggest likely root cause and severity.
• Visual / accessibility AI checks (Applitools, axe AI): catch UI regressions and a11y issues.

Example usage

The Quality Engineer lets AI post a first-pass review on a PR (catching a missing null check and an untested branch), approves after checking design intent, then takes the acceptance criteria into Claude for a full test matrix, scaffolds the automatable subset in Playwright, and signs off once CI is green - one person owning the whole quality arc.

flowchart LR
    PR[Pull Request] --> AIR[AI review + SAST]
    AIR --> H[Quality Engineer: review intent + security]
    H --> G{Code OK?}
    G -->|no| DEV[Back to Developer]
    G -->|yes| AC[Acceptance Criteria]
    AC --> AIM[AI generates test matrix]
    AIM --> AUTO[Scaffold automated tests]
    AUTO --> RUN[Run in CI]
    RUN --> R{Pass?}
    R -->|no| TRI[AI triage → Developer]
    R -->|yes| SO[Sign-off → Stakeholders]

Collaboration

The Quality Engineer reviews Developers’ PRs, validates against the BA’s acceptance criteria, aligns with the Architect on standards and non-functional testing, and provides the PM/BA with the evidence stakeholders need to accept the increment. They feed defect trends into the Retrospective.

Definition of Done for this role

• Every PR has passed AI + human review with no blocking comments; security/quality gates green.
• Coverage and standards thresholds met.
• Test cases trace to acceptance criteria; automated functional/regression tests pass in CI.
• Defects reported, triaged, and fixes verified.
• The increment is signed off as meeting acceptance criteria, or rejected with clear reasons.

Pitfalls & anti-patterns

Watch out

• Rubber-stamping AI-approved PRs. AI review reduces effort, not accountability - a human owns the approval.
• Tests that pass but assert nothing. Review assertions, not just coverage numbers; a green test that checks nothing gives false confidence.
• Alert fatigue. Tune scanners and use AI triage, or the team starts ignoring real findings.
• Quality as an end-of-sprint gate. Review PRs continuously and start test design at refinement - not in a Day-10 pile-up.
• Testing only the happy path. Use AI specifically to surface boundary, error, and security cases.
• Flaky suites ignored. A red suite people learn to ignore is a liability; fix or quarantine.