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. ๐
๐ฅ 7 QA automation trends we're seeing in 2026
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
clickandfill, 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
requestfixture 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
onlyFailuresoption (1.65) keep CI output focused on what broke. - The
retain-on-first-failurevideo 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()andpage.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
AbortSignalto 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 testworks 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.
- 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.
- 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.
- Week 3: put it in the pipeline. Run the suite on every pull request with sharding, traces on retry and
failOnFlakyTests. Add a weekly--shufflerun. - 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:
| Metric | What it tells you | What good looks like |
|---|---|---|
| โฑ๏ธ Pull request feedback time | How quickly a developer finds out they broke something | Under 15 minutes |
| ๐ฏ Critical journey coverage | How many of your top journeys are automated end to end | All of them |
| ๐งช Flaky test rate | Tests that only pass on retry | Under 1% |
| ๐ Escaped defects | Bugs your users find after a release | Going down each quarter |
| ๐ Release frequency | How often you can ship without stress | Weekly or better |
| ๐ Regression time | Code freeze to release-ready | Hours, 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.