QualityLabs

Your tests always pass, even when something is broken.

AI writes tests fast, but many pass whether the product works or not, so your reports look healthy while problems still reach customers. We keep the tests that catch real problems, fix or remove the rest, and set a simple review standard so it does not happen again.

Generated, never reviewed

test('checkout works', async ({ page }) => {
  await page.goto('/checkout');
  await page.waitForTimeout(3000);

  const btn = page.locator('.btn-primary').first();
  if (await btn.isVisible()) await btn.click();

  expect(true).toBeTruthy(); // green forever
});

What survives the review

test('charged exactly once', async ({ page }) => {
  const cart = await seedCart({ sku: 'SKU-118' });

  await page
    .getByRole('button', { name: 'Place order' })
    .click();

  await expect(page).toHaveURL(/\/confirmation\//);
  expect(await chargesFor(cart)).toHaveLength(1);
});

Your team builds faster than it can check.

AI lets your team make far more changes, but nobody changed how they get checked, so some now go out unchecked. We work out what really needs testing, make the rest fast and automatic, and give the people who check the work the same AI tools as your developers.
Everything works until your busiest day.

A sale, a campaign or a launch can bring more visitors than your systems have ever seen, and that is when slow pages and crashes appear. We recreate that traffic before the day comes, find what breaks first, and tell you how many customers you can handle and what to fix to handle more.

What we run

A normal day, your busiest hour, and a run long enough for slow leaks to show themselves.

What we look for

The first part of the system to max out, and then the one behind it that was the real limit all along.

What you keep

The breaking point, what causes it, and the change we would make to raise it.
Old tests that cost more than they catch.

Years of old tests cost time and servers to keep running, and their results are often ignored. Still, they know things about your product nobody wrote down. We sort out which to keep, which to move to modern tools and which to retire, so you only pay for tests that earn their place.

Step one

An inventory. A good share of most old tests is not worth moving at all, and we say which part is the valuable bit.

Step two

A trial run on roughly 10 to 15% of the tests, working for real, so the cost of the rest is known rather than guessed.

Step three

The rest, with a named person on your side involved from the first day rather than at the handover.
Customers feel the slowness your reports miss.

Buttons that take a moment to respond, pages that jump while they load, screens that arrive in pieces. None of it shows up in your reports, but customers notice, and some leave. We measure it on your customers’ own devices, find the cause of each problem and tell you the change that fixes it.

LCP

How long before the thing the page is actually for is on screen.

INP

How long the interface takes to answer a tap. The one most teams have never looked at, and the one users describe as the site feeling heavy.

CLS

How much the page moves after somebody has started reading it.

What we do

Website testing

Every time your website changes, automated tests click through it like a customer would.

Backend testing

Automated tests check the work behind the screen, like saving orders and charging cards.

Mobile app testing

Automated tests tap through your iPhone and Android apps like a customer would.

Migrating old tests

Old tests that are slow or keep breaking, moved to a modern tool or looked after where they are.

Reviewing AI tests

We check tests written by AI, keep the ones that work and fix the ones that don’t.

Load testing

How many visitors your product can handle before it slows down, and what breaks first.

Real-user performance

How fast your product feels on your customers’ own devices, and how to make it faster.

Tests on every change

Your tests run on their own every time your team changes something, fast enough that nobody skips them.

Training

We teach your team to test well, and to use AI for testing without trusting it blindly.

Tools we work in

Playwright
TypeScript
Python
k6
Lighthouse
Web Vitals
Selenium
Cypress
WebdriverIO
Puppeteer
Appium
XCUITest
Espresso
GitHub Actions
GitLab CI
Azure DevOps
Jenkins

How it works

Audit

About a week, free: we look at your tests and give you a written plan.
Trial run

We do a real part of the work first, not a demo, so you see it working.
Implementation

We build or move the rest of your tests in stages, checking each as we go.
Handover

You get full documentation and, if you want, workshops for your team.

Estimate your potential savings

Engineers on the product 8

Everyone who ships code to it.

Tests you need 400 · Professional

Enough to cover what you check by hand before a release.

Cost of one engineer hour €70/h

Salary plus overheads, in euros.

Your team QualityLabs

Every month until the suite works: €27,000
Manual testing: €3,700
Flaky pipelines: €4,700
Bugs in production: €5,600
Test debt: €4,700
Churn and onboarding: €1,100
Tech debt: €6,700

Your team builds it in: 5 months
Building it yourselves: €120,000
We deliver it in: 6 weeks
Our package, plus your time with us: €38,000

Saved over 5 months

€120,000

Doing it yourselves costs about 3.2 times as much, and takes 5 months instead of 6 weeks.

How this is worked out

Rules of thumb, not measurements. An engineer month is 160 hours and a month is 4 weeks. Where a figure comes from published research, the source is linked.

Writing the tests: 3.2 hours per test, with a quarter of the team on it and never more than two people. A quarter of that time goes on ramp-up, rotations and handovers, so each test takes about 4.3 hours.
Manual testing: 2 minutes per test at each release with a flaky suite, 5 with manual checks only. Four releases a month, capped at a quarter of the team’s time.
Flaky pipelines: 3 reruns a week per engineer, 40 minutes each, plus about €2 of CI time per rerun. See Google, Microsoft Research and GitHub Actions pricing.
Bugs in production: 1 a month for every 4 engineers, or 2 for every 5 with manual checks only, at 40 hours each. Why late bugs cost more: NIST, 2002.
Test debt: 10 minutes per test a month keeping a flaky suite running, 2 keeping manual checklists current. Capped at 15% of the team’s time.
Churn and onboarding: 15% of engineers leave each year. Without tests, a new hire needs about a month longer before they can change code safely.
Tech debt: 3 hours a week per engineer, 4 with manual checks only. Surveys put the total at 6 to 13.5 hours: Stepsize, 2021 and Stripe, 2018. On AI-written code and delivery stability: DORA, 2024.
Once the suite works: Costs fall as tests land, on both routes. What any working suite still leaves, a fifth of each cost and half of the tech debt, is the same either way, so it is left out and both lines go flat.
With us: The package price paid in steps: 20% at the start, 30% after the trial run, 30% after implementation and 20% at handover. Plus 60 hours of your team’s time for up to 200 tests or 120 for up to 600, and your monthly costs for the 3 or 6 weeks we take. For an example of the pace, see two weeks, 200 tests. After handover the service ends, unless you want us to maintain the tests, from €5,000 a month.

Most of the saving is engineering time returned to the product, not cash. Web packages cost from €12,000 for up to 200 tests and from €30,000 for up to 600. Mobile packages cover fewer tests, and above 600 the price is set after the free audit.

Disclaimer

An estimate from your answers, not a quote, a promise of savings or part of any contract. What you pay is set in your written scope.

What people ask before the audit

What do we actually get from the free audit?

A written report on what your tests check today, what they miss, and what to do next. It takes about a week and very little of your team’s time. The report is yours to keep, even if you don’t hire us. And if you need less than you think, we will tell you.

How does a project work?

In four steps: the audit, a trial run on a small part of the work, the main work, and a handover to your team. Each step gives you something useful on its own, so you can stop after any of them. See the four steps.

We hardly have any automated tests. Is it too early to call you?

No, it is a good time. With little in place, there is nothing to undo. We add tests where you have none, help you decide which manual checks are worth automating, and make them run on their own in the tools you already use. Your team learns good habits early, when it is easiest.

We already have tests. Do we have to start over?

No. Tests that work well, we keep and improve, whatever tool they are written in. Tests that cost more than they are worth, we replace step by step, never all at once, and some are better simply deleted. The audit tells you which is which.

How long does it take?

The audit takes about a week. After that, it depends on the size of your product and the state of your tests.

What happens once you leave?

Your team is ready to carry on without us. At handover you get documentation about the project and knowledge-transfer workshops (on request).

If you want us around after that, we offer support at different levels, and you can extend it whenever you need to.

Start with a free audit

Free, no commitment
About a week
The report is yours to keep
EU company, under GDPR
NDA signed before we see code

Book a free audit call or write to hello@qualitylabs.eu

AI made development faster. Testing didn’t keep up.

What we get called in for

Your tests always pass, even when something is broken.

Your team builds faster than it can check.

Everything works until your busiest day.

Old tests that cost more than they catch.

Customers feel the slowness your reports miss.