Test automationPlaywrightQA strategy

QA Automation Trends 2026: Skills, Coverage and Playwright Features to Ship Faster

What we're seeing in QA automation in 2026: the skills that matter, how to think about test coverage, and the new Playwright features that help teams ship faster.

SQA Point Team 12 min read

Here's a conversation we have with almost every new client. The developers want to ship every week. QA is still running a two-day regression before each release. Everyone is a bit frustrated, and someone eventually asks, "Can't we just automate all of it?" ๐Ÿ˜…

The honest answer is: not all of it, and you shouldn't try. But you can get to a place where every pull request is checked against the things that really matter, in minutes, without anyone babysitting a spreadsheet. That's what this post is about.

We'll go through the trends we're actually seeing in QA teams this year, the skills that make the biggest difference, how we think about test case coverage, and the newest Playwright features (up to 1.65) that are worth your time. It's a long one, so grab a coffee โ˜• or jump around with the contents list.

The short version, if you're busy ๐Ÿ‘‡

  • AI agents can now draft and repair tests. That doesn't replace your team; it changes what they spend their day on.
  • Stop counting test cases. Cover your critical journeys end to end and push the edge cases down to API and unit tests.
  • Treat a flaky test as a failing test. Recent Playwright releases finally give you the tools to do that properly.
  • There's a simple 30-day plan near the end if you want somewhere to start.

๐Ÿ“ˆ Speed versus coverage is a false choice

A lot of teams still believe that more testing means slower releases. With manual testing, that's true. Every new feature adds to the pile, and the regression window keeps growing.

Automation flips it around. Once your important flows are covered and running in parallel on every change, adding coverage barely touches your release time. In our experience the teams that ship fastest usually have more automated checks than the slow ones, not fewer. They just run them earlier and spread them across machines.

And the money side is simple: a bug caught in a pull request is a ten-minute fix for the developer who just wrote the code. The same bug found by a customer turns into a support ticket, a hotfix, a rushed release and an awkward email. ๐Ÿ™ƒ

1. AI agents have joined the team ๐Ÿค–

A year ago "AI testing" mostly meant autocomplete for selectors. Now agents can open your app, click around, write a test plan, generate the tests and fix them when the UI changes. Playwright even ships its own agents and a built-in MCP server. We use them a lot, and they save real time, but we read every test they write. They're quick to write a test that passes without actually checking anything useful.

2. Coverage is measured in risk, not numbers ๐ŸŽฏ

"We have 3,000 test cases" used to sound impressive. Now the better question is whether the checkout, the login and the payment flow are covered on every build. Teams are deleting low-value tests and getting faster, more trustworthy suites as a result.

3. Nobody tolerates flaky tests anymore ๐Ÿงช

Once people learn to ignore a red build "because that test is always flaky", your suite has stopped protecting you. The healthier teams we work with treat any test that passes only on retry as broken, and fix it that week.

4. Testing moves both left and right โฌ…๏ธโžก๏ธ

Left means tests run on every pull request, before code is merged. Right means watching production with synthetic checks and error monitoring, and turning real incidents into new tests. You need both. Neither one catches everything.

5. Accessibility is now part of "done" โ™ฟ

With accessibility regulations getting stricter in many markets, a11y checks are moving into CI next to the functional tests. It's also just good testing. A page with broken labels is usually a page with other problems too.

6. Setup happens through the API ๐Ÿ”Œ

If your UI test spends 40 seconds registering a user and filling a cart before it checks the one thing it's there for, it's slow and fragile. More teams now create test data through the API and reuse a signed-in session, so the browser only does the part that matters.

7. Test results people outside QA can read ๐Ÿ“Š

Traces, videos and timing reports mean you can show a product owner exactly what failed and why, without a 20-minute explanation. That makes go/no-go decisions faster and a lot less political.

๐Ÿง  The skills that actually make a difference

Tools change every few months, so we hire and train for skills that carry over. If we were building a QA automation team from scratch today, this is the list we'd focus on:

  • Thinking in risk. Being able to sit with a product owner and work out what would really hurt if it broke. This one skill shapes everything else.
  • Writing good TypeScript. Test code is real code. If it's messy, it gets slow to change and people stop trusting it. Reviews, linting and sensible fixtures matter.
  • Knowing Playwright well. Not just click and fill, but fixtures, projects, storage state and the trace viewer. That's where most of the speed and stability comes from.
  • API testing. API tests run in milliseconds and are the right place for most edge cases. Playwright's request fixture makes this easy to add to the same suite.
  • Owning the pipeline. Sharding, caching, artifacts, reports. A QA engineer who can fix the CI config is worth a lot.
  • Working with AI agents. Knowing how to give an agent good instructions, and, more importantly, how to spot when it's produced something that looks right but isn't.
  • Accessibility basics. Enough WCAG knowledge to know what a role, a label and a heading level are for.
  • Explaining quality clearly. A short release note that says "here's what we checked, here's what worries us" beats a 400-row pass/fail export every time.

๐ŸŽฏ How we think about test case coverage

The question we ask instead of "how many tests do we have?" is: if this broke tonight, would a test tell us before a customer does? Here's how we get to a yes.

Start with your critical journeys ๐Ÿ—บ๏ธ

Write down the flows that make money or lose trust when they break. Sign-up, login, search, add to cart, checkout, payment, password reset, that kind of thing. For most products this list lands somewhere between 15 and 25 journeys. Those get full end-to-end automation first, and they run on every pull request.

Pick the cheapest layer that catches the bug ๐Ÿงฎ

For each feature, think about how bad a failure would be and how likely it is to break. Then put the test at the lowest layer that can catch it:

  • Unit tests for rules and maths: tax, discounts, validation.
  • API tests for permissions, error codes and all the awkward data combinations.
  • End-to-end UI tests for the real user journeys on real browsers.
  • Visual and accessibility checks for layout, contrast and screen-reader structure.

Make coverage easy to trace ๐Ÿ”—

Tag tests with the journey or requirement they cover, like @checkout or @critical. It sounds boring, but it means you can run just the slice a change affects, and you can answer "is the refund flow covered?" in five seconds.

๐Ÿ’ก A rule we use all the time

If a test needs more than three UI steps just to get to the thing it's testing, do that setup through the API instead. The test gets faster, and there are fewer places for it to break for the wrong reason.

๐ŸŽญ The newest Playwright features worth your time

Playwright releases roughly once a month, and honestly it's hard to keep up. These are the features from versions 1.56 to 1.65 that we think make the biggest difference to coverage and release speed. We've put the version next to each one so you can check whether your project already has it.

๐Ÿค– Test Agents: planner, generator and healer 1.56

This is the big one. The planner explores your app and writes a test plan in Markdown. The generator turns that plan into Playwright tests and checks the locators against the live page. The healer runs failing tests and tries to repair them. If you're starting from zero, it's the quickest way we know to get a first suite on the board.

# Add the planner, generator and healer agents to your repo
npx playwright init-agents --loop=vscode   # or --loop=claude / --loop=opencode

A word of caution from experience: review what the generator writes. It sometimes asserts that a page loaded rather than that the right thing happened. Since 1.62 there's also npx playwright mcp and npx playwright cli built in, so coding assistants can drive a real browser with no extra setup.

โ™ฟ Aria snapshots 1.60, 1.63

We really like this one. expect(page).toMatchAriaSnapshot() checks the accessible structure of a page (headings, labels, roles, button names) in a single readable assertion. It catches the kind of thing screenshots miss, like an input that lost its label, and it doesn't break every time someone tweaks the CSS. 1.63 added ariaSnapshotJSON() if you want to write your own checks on top.

import { test, expect } from '@playwright/test';

test('checkout page structure is accessible', async ({ page }) => {
  await page.goto('/checkout');

  // One assertion covers headings, labels and button names. (page-level: 1.60)
  await expect(page).toMatchAriaSnapshot(`
    - heading "Checkout" [level=1]
    - textbox "Email address"
    - textbox "Card number"
    - button "Place order"
  `);
});

๐Ÿ”’ Test locks 1.63 to 1.65

You know the situation: two tests both change the same admin setting, and when they run in parallel they trip over each other. The old fix was to make the whole file serial and lose your parallel speed. Now you just put a lock on the tests that clash. 1.64 lets you set it on test.describe.configure(), and 1.65 adds an exclusive lock for tests that need the whole stage to themselves.

// These two share the store settings, so they never run at the same time.
// Everything else in the suite stays fully parallel. (1.63)
test('admin can change store currency', { lock: 'store-settings' }, async ({ page }) => {
  // ...
});

test('checkout shows prices in store currency', { lock: 'store-settings' }, async ({ page }) => {
  // ...
});

๐Ÿ”€ Shuffle 1.64

Some tests only pass because another test happened to run first and left data behind. You won't notice until the order changes on CI. --shuffle randomises the order on purpose, and the seed lets you replay the exact run that failed. We run it once a week rather than on every build.

# Run in random order to flush out tests that depend on each other (1.64)
npx playwright test --shuffle

# Got a failure? Re-run with the same seed to get the same order
npx playwright test --shuffle 4821

# Skip a tag: -G is short for --grep-invert (1.61)
npx playwright test -G @slow

# Only run tests affected by your branch
npx playwright test --only-changed=origin/main

๐Ÿงช Isolated retries and failing on flakes 1.62

retryStrategy: 'isolated' retries a failed test in a fresh worker, so leftovers from earlier tests can't mess with the result. Add failOnFlakyTests and a test that only passes on the second try fails the build. It's a bit painful for the first week. After that, your suite gets very quiet, in a good way.

๐Ÿ“Š Speedboard, Timeline and the failures reporter 1.57, 1.58, 1.65

  • The Speedboard tab in the HTML report (1.57) shows your slowest tests, so you know where to look first.
  • The Timeline view (1.58) shows how a sharded run actually spent its time.
  • The failures reporter and the onlyFailures option (1.65) keep CI output focused on what broke.
  • The retain-on-first-failure video mode (1.61) keeps a recording of the first failure without storing videos of every passing test.

๐Ÿ” Passkeys and browser storage 1.61

Passwordless sign-in used to be a pain to automate. browserContext.credentials gives you virtual WebAuthn passkeys, so you can test that flow end to end. There are also new page.localStorage and page.sessionStorage APIs, which beat writing little evaluate scripts to seed state.

โšก Smaller things we've found handy

  • page.consoleMessages() and page.pageErrors() (1.56) make it easy to fail a test if the journey threw JavaScript errors along the way.
  • webServer.wait (1.57) waits for a log line from your app, so tests start as soon as it's really ready instead of after a guessed timeout.
  • You can pass an AbortSignal to actions, waits and assertions (1.62) for tighter control over timeouts.
  • WebP screenshots (1.62) keep visual baselines smaller.
  • And if your team is on Bun, bunx --bun playwright test works now (1.65).

โš™๏ธ The config we usually start with

This is close to the playwright.config.ts we start most new projects with. It runs everything in parallel, signs in once in a setup project, only keeps traces and videos when something goes wrong, and treats flaky tests as failures on CI. Adjust it for your app, of course.

import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  testDir: './tests',
  fullyParallel: true,
  forbidOnly: !!process.env.CI,

  // Retry once on CI, in a fresh worker, and fail the run if a test only passed on retry.
  retries: process.env.CI ? 1 : 0,
  retryStrategy: 'isolated',          // 1.62
  failOnFlakyTests: !!process.env.CI, // flaky = broken, not "green"

  reporter: process.env.CI
    ? [['failures'], ['html', { open: 'never' }], ['junit', { outputFile: 'results.xml' }]] // 1.65
    : [['list'], ['html']],

  use: {
    baseURL: process.env.BASE_URL ?? 'http://localhost:3000',
    trace: 'on-first-retry',
    video: 'retain-on-first-failure',   // 1.61
    screenshot: 'only-on-failure',
  },

  projects: [
    { name: 'setup', testMatch: /.*\.setup\.ts/ },
    { name: 'chromium', use: { ...devices['Desktop Chrome'] }, dependencies: ['setup'] },
    { name: 'mobile', use: { ...devices['Pixel 7'] }, dependencies: ['setup'] },
  ],
});

To upgrade, run npm i -D @playwright/test@latest and then npx playwright install. If you're jumping several versions, skim the official Playwright release notes first. It takes ten minutes and can save you an afternoon.

๐Ÿ—“๏ธ If you only do one thing: a 30-day plan

This is roughly the plan we follow when we join a team that wants faster releases. Nothing fancy, just steady progress you can see each week.

  1. Week 1: work out where you are. List your critical journeys and agree on which ones would hurt most if they broke. Write down how long regression takes today, how often you release and how many bugs reach customers. You'll want those numbers later.
  2. Week 2: automate the top ten. Let Playwright's agents draft tests for your ten most important flows. Then spend the real effort reviewing them: proper role-based locators, API setup and assertions that check the outcome.
  3. Week 3: put it in the pipeline. Run the suite on every pull request with sharding, traces on retry and failOnFlakyTests. Add a weekly --shuffle run.
  4. Week 4: widen it and start reporting. Add the next ten journeys and aria snapshots on your key pages, and send a one-page quality summary with each release.

If you'd like to see this in action, our live automation demo shows an agent exploring a store, writing test cases and running 20 critical tests, with the full report at the end.

๐Ÿ“ Metrics worth tracking

You don't need a fancy dashboard. Track a handful of numbers every month and you'll know whether all of this is paying off:

MetricWhat it tells youWhat good looks like
โฑ๏ธ Pull request feedback timeHow quickly a developer finds out they broke somethingUnder 15 minutes
๐ŸŽฏ Critical journey coverageHow many of your top journeys are automated end to endAll of them
๐Ÿงช Flaky test rateTests that only pass on retryUnder 1%
๐Ÿž Escaped defectsBugs your users find after a releaseGoing down each quarter
๐Ÿš€ Release frequencyHow often you can ship without stressWeekly or better
๐Ÿ” Regression timeCode freeze to release-readyHours, not days

โœ… Wrapping up

Shipping faster isn't about testing less. It's about testing the right things automatically, on every change, and making failures easy to understand. Cover your critical journeys, use Playwright's newer features to keep the suite fast and stable, let AI take the repetitive work, and treat every flaky test like the bug it is.

If you'd like a hand with any of this, have a look at our software QA and test automation services or just drop us a message. We're always happy to look at a suite and point out the quick wins. ๐Ÿ™Œ

โ“ Frequently asked questions

What is the latest version of Playwright?

At the time of writing (November 2026) it's Playwright 1.65. The headline additions are a Bun test runner, a new failures reporter, an onlyFailures option for the HTML, JSON and JUnit reporters, and an exclusive test lock for tests that need to run completely on their own.

What are Playwright Test Agents?

They arrived in Playwright 1.56. There are three of them: a planner that explores your app and writes a test plan, a generator that turns that plan into Playwright tests, and a healer that runs failing tests and tries to fix them. You add them with npx playwright init-agents and use them from VS Code, Claude Code or opencode. Treat what they produce as a first draft that still needs a human review.

How much test coverage is enough before a release?

We'd rather see every critical user journey covered end to end than chase a percentage. For most products that means automating somewhere around 15 to 25 key flows, then using API and unit tests for the edge cases underneath them.

Will AI replace QA automation engineers?

We don't think so. AI is great at the repetitive parts: drafting tests, exploring screens, patching a broken locator. It's not good at deciding what matters to your business, judging risk or saying 'this isn't ready to ship'. That judgement is the job, and it's becoming a bigger part of it.

How do I reduce flaky tests in Playwright?

Start with role-based locators and web-first assertions, and give each worker its own test data. Then run with --shuffle now and then to catch tests that depend on order, put a lock on tests that share something, and turn on failOnFlakyTests in CI so retries stop hiding the problem.

All articles

Want this level of automation on your product?

SQA Point builds Playwright frameworks, risk-based test suites and CI pipelines that let teams release with confidence.

Talk to a QA expert