We write your Playwright suite. Then we keep it green.
Most teams get a suite to thirty percent coverage, watch it go red for reasons nobody can explain, and quietly stop trusting it. We take that job over. The specs, the selectors that break on every design tweak, the 3am failure that turns out to be a timeout.
- Written in
- Standard Playwright
- Lives in
- Your repository
- If you leave
- Nothing to rip out
The first four weeks
You give us access and tell us what must never break. We do the rest. The goal for month one is your critical flows under test and a suite that stays green without anyone on your team babysitting it.
- Week 1
We map what matters
We walk your app the way your users do and write down the flows worth protecting. Login, checkout, the admin screen everyone is scared to touch. You approve that list before we write a line of code.
- Weeks 2–4
We write the specs
Real Playwright, in your repository, on a branch you review. Role and test-id locators, honest waits, and no sleep(3000) papering over a race condition.
- Ongoing
We own the failures
Every run comes to us first. A broken selector gets fixed. A real bug gets a trace, a repro, and a message to the person who can act on it.
It is your code. You could fire us tomorrow.
- Plain Playwright
- No wrapper, no DSL, no runtime of ours in your package.json.
- In your repository
- We work on branches and open pull requests. You review the diff before it lands.
- Read by a person
- AI drafts and triages. Someone here reads the result, because a confident wrong test is worse than no test.
import { expect, test } from '@playwright/test';test('checkout completes with a saved card', async ({ page }) => {await page.goto('/cart');await page.getByTestId('cart-line-item').first().waitFor();await page.getByRole('button', { name: 'Checkout' }).click();await page.getByRole('radio', { name: /Visa ending 4242/ }).check();await page.getByRole('button', { name: 'Place order' }).click();await expect(page.getByTestId('order-confirmation')).toBeVisible();await expect(page).toHaveURL(/\/orders\/\d+/);});
Lightly anonymised. Roles and test ids, so a restyle does not take the test down with it.
A suite nobody runs is a suite nobody trusts.
Writing the tests is the easy half. We schedule them, watch every run, and put failures in front of the person who can fix them. If a run goes red because of something we did, you never hear about it.
- Browser journeys
- The suite we wrote, on a schedule, from the regions your customers actually sit in.
- API and database checks
- Endpoints, plus Postgres, MySQL and Redis reachability, so a green UI on a dead backend gets caught.
- Certificates and uptime
- URL, TCP, UDP and SSL expiry, because the most embarrassing outages are never in the code.
You are not choosing between us and nothing.
You are choosing between us, a hire, and doing it yourselves. Two of those are genuinely better than us at something, so here is the comparison with those parts left in.
| Concern | Managed QA | An in-house QA hire | Your team, between features |
|---|---|---|---|
| Time to the first covered flow | Days. We start on your top flows in week one. | Months. Hiring, notice period, onboarding, then learning the product. | Whenever a sprint has room, which is usually the problem. |
| Product knowledge | We learn it. That costs you a few hours a week for the first month. | The deepest of the three. They live in the product every day. | Already there. Nobody knows it better than the people who built it. |
| Who triages a red run | Us, before it reaches you. | Them, during their working hours. | Whoever opens the CI tab first. |
| Holiday, illness, notice period | Covered. It is a team, not a person. | The suite goes quiet until they are back. | Same people, same load, no change. |
| When a release deadline hits | Coverage continues. It is not your sprint. | They usually get pulled onto release work. | Tests are the first thing dropped. |
| What you own at the end | Plain Playwright in your repository. | Everything, plus an engineer who knows it cold. | Everything. |
Tell us what you never want to break.
Send the flows that would ruin your week if they went down. We come back with what we would cover first, in what order, and what that takes. No deck, no discovery call before you know whether this is worth your time.
- Login, signup, billing and admin.
- The journeys your customers would notice within minutes.
- Any flaky checks you want us to absorb and stabilise.
Before you ask
The six questions that come up on every first call, answered before the call.
You do. They live in your repository, under your license, written in standard Playwright. If you stop working with us tomorrow, the suite keeps running and any engineer can pick it up.
Some of it will, and that is the part you are paying us for. We lean on role and test-id locators so a restyle does not take a spec down, and when a real change lands we update the spec that day instead of leaving a red run for you to interpret.
Send them anyway. We usually keep more than teams expect. The genuinely flaky ones get rewritten or deleted, and we tell you which is which rather than quietly skipping them.
A staging environment, a couple of test accounts, and about thirty minutes a week from someone who knows the product well enough to settle an argument about intended behaviour. That is close to all of it.
It depends on how much surface area you want covered and how fast it changes. We quote after the coverage review, so the number reflects your app rather than a plan tier you have to squeeze into.
No. The suite is plain Playwright and runs in your own CI if that is what you want. Teams who let us run it get scheduling, multi-region runs, and alert routing without having to build any of that themselves.