QA Automation Lead

We’re looking for a QA Automation Lead who enjoys owning product quality end-to-end and building a full testing platform — not just browser automation.

You’ll lead quality engineering across frontend, backend, APIs, and integrations: test strategy, automation frameworks, CI gates, release confidence, and how engineering teams ship safely. This is a role for someone who wants to do more than write brittle UI scripts or file bugs after the fact — you’ll design the quality system across unit, component, API, contract, integration, smoke, sanity, regression, and end-to-end testing, raise engineering standards, and make testing a force multiplier for the whole team.

You’ll have meaningful ownership over how we know a release is safe.

What you’ll do

• Own quality strategy from risk assessment through automation, CI enforcement, release readiness, and continuous improvement.

• Design and maintain a full layered test strategy across:

• Unit testing — fast, isolated coverage for business logic and critical functions

• Component / module testing — UI and service units with controlled dependencies

• API / service testing — request/response correctness, auth, errors, and edge cases

• Contract testing — consumer–provider contracts so frontend, backend, and services don’t break each other silently

• Integration testing — real interactions across services, databases, queues, and third-party dependencies where needed

• Smoke testing — minimal post-deploy / post-merge checks that the system is alive and critical paths work

• Sanity testing — focused checks after bug fixes or small changes to confirm intended behavior without full regression

• Regression testing — broader automated packs that protect existing behavior as the product evolves

• End-to-end (E2E) testing — critical user journeys across the real product stack (UI + API + backend)

• Non-functional checks where valuable — accessibility smoke, performance smoke, visual regression, security-minded checks

• Build and scale reliable automation for UI, API, and service layers (Playwright, API frameworks, unit/component runners) that is deterministic, maintainable, and valuable in CI.

• Decide which layer owns which risk — keep E2E thin; push most coverage down to unit, API, and contract tests.

• Partner with frontend, backend, and product to define acceptance criteria, edge cases, and risk-based test plans before features ship.

• Establish quality gates in CI/CD — PR gates (unit/component/contract), merge/deploy smoke, nightly/full regression, and how flaky tests get fixed instead of ignored.

• Own test data, environments, fixtures, mocks/stubs, and hermetic setup so automation is reproducible across local, PR, staging, and production-like checks.

• Improve defect discovery early: shift-left unit/API testing, exploratory testing where automation is weak, and clear bug reports with repro steps.

• Drive release confidence — smoke + sanity + critical E2E + regression signals that engineers trust for go/no-go.

• Reduce flakiness ruthlessly across UI and API suites: isolate root causes, harden waits/contracts/fixtures, and keep CI green.

• Mentor QA and engineers on writing testable code, good assertions, and ownership of quality beyond “QA’s job” or “only browser tests.”

• Track meaningful quality metrics (escape rate, flake rate, suite runtime, critical-path coverage by layer) — not vanity dashboards.

• Participate in architecture and design reviews to surface testability, failure modes, contract boundaries, and observability gaps early.

• Work with DevOps/platform on test environments, secrets, parallelization, and pipeline performance.

• Make pragmatic quality decisions without blocking the business on ceremony.

• Help hire and grow a strong QA / SDET capability as the company scales.

What we’re looking for

• At least 5+ years in QA automation / SDET roles, including leadership or ownership of a meaningful automation / quality platform.

• Strong experience across multiple test types, not only browser E2E — unit, API, contract, integration, smoke, sanity, regression, and E2E.

• Strong understanding of the test pyramid and when E2E is the wrong tool.

• Experience owning quality outcomes rather than only executing manual test cases.

• Strong debugging skills across UI, network, APIs, services, auth, data, and environment failures.

• Experience making flaky suites reliable and keeping CI trustworthy.

• Good understanding of web + backend architecture: REST/JSON APIs, auth/sessions, async jobs, and service boundaries.

• Ability to risk-rank what must be tested at which layer vs what can wait.

• Clear written communication — bug reports, test plans, and failure analysis that engineers can act on.

• Comfort working with ambiguity and incomplete requirements.

• Ability to balance speed, coverage, maintainability, and release risk.

• Experience mentoring others and raising quality standards across engineering.

• Strong ownership mindset: you chase a failure to root cause, not just reopen the ticket.

Nice to have

• Deep Playwright experience for critical-path E2E (fixtures, projects, tracing, parallelization, auth setups).

• Experience with Vitest/Jest, React Testing Library, JUnit/pytest, or similar unit/component frameworks.

• Experience with contract testing (Pact, OpenAPI/schema validation, consumer-driven contracts).

• Experience designing smoke vs sanity vs full regression suites and wiring them to the right CI/CD stages.

• Experience with API testing (Postman/Newman, REST Assured, Supertest, k6, or custom frameworks).

• Experience with integration testing against Postgres, Redis, Kafka, or similar dependencies.

• Experience with visual regression, accessibility automation, and performance smoke checks.

• Experience testing complex B2B / SaaS workflows (multi-tenant, roles/permissions, long-running jobs).

• Experience designing test environments, seed data, and ephemeral CI environments.

• Experience with GitHub Actions / GitLab CI and making multi-layer suites fast enough that engineers actually run them.

• Experience with defect triage, release management, and quality scorecards.

• Experience with security-minded testing (authZ gaps, IDOR-style checks, secrets in logs) in partnership with Security.

• Experience hiring and growing SDET / QA automation engineers.

• Experience working at an early-stage or high-growth startup.

Tech stack

We believe most technologies can be learned when needed. However, knowing the following is a huge plus:

• Unit / component: Vitest, Jest, React Testing Library, pytest, or equivalent.

• API / service: Supertest, REST Assured, Postman/Newman, custom TypeScript/Python/Go harnesses.

• Contract: Pact, OpenAPI/JSON Schema validation, consumer-driven contracts.

• E2E / UI: Playwright (or similar) for critical user journeys.

• Smoke / sanity / regression orchestration in CI (GitHub Actions, GitLab CI, or similar).

• TypeScript / JavaScript / Python / Go for automation frameworks and tooling.

• Docker for reproducible test runners and dependencies.

• Browser DevTools / traces / HAR / API logs for failure diagnosis.

• Allure / Playwright reports / JUnit reports for readable failure artifacts.

• Familiarity with React / Next.js frontends and REST / event-driven backends so you can test the whole system intelligently.

What we value

Quality ownership over QA handoffs

You don’t throw bugs over the wall and move on. You help get to root cause and prevent the class of failure.

Full-stack quality over browser-only automation

E2E is one tool. Real quality comes from the right mix of unit, API, contract, integration, smoke, sanity, regression, and E2E.

Signal over suite size

A thousand flaky tests are worse than fifty reliable ones. We care about trust in the green check.

Shift-left over late discovery

The cheapest bug is the one that never ships. Unit/API/contract automation and clear acceptance criteria beat last-minute manual panic.

Risk-based testing over exhaustive theater

Not every path deserves an E2E. Protect critical journeys; push the rest down the pyramid.

Determinism over “it failed again, rerun”

Flakes are defects in the test system. We fix them.

Partnership with engineering

QA automation leads who understand the product and codebase make better suites than people who only click through the UI.

Engineering judgment over checklist QA

Process helps. Understanding failure modes helps more.

Taking responsibility for release confidence, not just test count

The goal is shipping valuable software safely — not maximizing case count.

This is a high-ownership leadership role where you’ll have meaningful influence over release quality, automation platforms, and engineering culture.

Probably skip

• Looking for a narrowly scoped manual-only or browser-only automation role with no interest in API/unit/contract strategy.

• You measure success by number of test cases written rather than bugs prevented and CI trust.

• You accept flaky tests as normal and tell people to “just rerun.”

• You only test happy paths and ignore auth, permissions, empty states, and failure modes.

• You believe E2E should cover everything and unit / API / contract tests are optional.

• You are uncomfortable reading logs, network traces, API responses, or frontend/backend code.

• You file bugs without repro steps, expected vs actual, or environment context.

• You want to be a pure gatekeeper who blocks releases without helping fix quality.

• You conflate smoke, sanity, and full regression and run the wrong suite at the wrong stage.

• You rely on AI-generated selectors and scripts without understanding why they flake.

• You are uncomfortable with ambiguity, changing priorities, or early-stage startup constraints.

• You leave known quality gaps unresolved because “engineering owns that.”

• You leave the release process on fire.

• Your primary engagement is standup.

• You have lots of other engagements in real life and working in a fast-paced environment is your liability.