Your company cut QA. Or never had one. Either way, the tests are your problem now. The bug reports land in your DMs. The flaky CI run at 2am is your pager. The real cost of no QA team does not disappear when the headcount does. It gets billed straight to the developers left holding the suite.
Nobody put a line item for this on the roadmap, so it feels free. It is not free. You are paying for it in hours, CI minutes, LLM tokens, and context-switches that never show up on a dashboard.
Let's do the math. All of it. Then let's talk about why developers doing QA are the ones most underwater, and what a zero-cost stack actually looks like.
The six invisible line items
When a dedicated QA team disappears, the cost does not vanish with it. It just gets redistributed into categories that are hard to see on a budget spreadsheet. Here are the six we will price out:
- Manual test maintenance - fixing flaky selectors, rewriting assertions, chasing timing bugs.
- CI compute for reruns - the "just rerun it, it'll pass" tax.
- Escaped incidents - bugs that reached production because no one was looking in the right place.
- LLM tokens for test generation - if you pipe Cursor or Claude at every test run.
- Context-switch cost - the productivity tax of bug triage interrupting real work.
- Fully-loaded engineering time - because all of the above converts back into your hourly rate.
We will use $75/hr as the proxy for a fully-loaded developer (a common approximation for a $150k/year total comp engineer once you include benefits, equipment, and overhead). Adjust up or down for your market.
1. Manual test maintenance
Internal instrumentation across teams running Playwright or Cypress suites clocks in around 6 to 7 hours per developer per month spent fixing test infrastructure instead of shipping features. Call it 6.5 hours average.
That's 78 hours per developer per year.
78 hrs × $75/hr = $5,850 per developer per year
This is the single biggest line item, and it is the one you feel the most because it happens on Friday afternoons when you are trying to go home.
2. CI compute for reruns
Flaky tests force reruns. A conservative estimate: 3 full CI runs per day per developer, and 1 of those is a rerun. At roughly 15 minutes of parallel compute per E2E job and typical managed-runner pricing (~$0.008/minute for larger instances), that's about:
1 rerun/day × 15 min × $0.008 × 220 working days = ~$26/dev/year in raw compute.
Peanuts on its own. But add the human time to look at a failed rerun, investigate, and decide it was flaky: call it 10 minutes per rerun.
10 min × 220 days = ~37 hrs/yr × $75 = $2,775
So the compute is cheap. The "wait, what broke?" stare is not.
3. Escaped incidents
Without systematic E2E and visual coverage, things slip. A realistic number for a small product team with no dedicated QA is 2 to 4 customer-visible incidents per quarter that would have been caught by a proper regression suite - layout breaks, broken forms, silent 500s on a non-critical path.
Each incident costs, conservatively: 4 hours to investigate, fix, hotfix-deploy, and write the postmortem. Plus ~2 hours distributed across the team for the Slack war room.
3 incidents/qtr × 4 qtr × 6 hrs = 72 hrs/year × $75 = $5,400
This does not include the cost of customer trust, support tickets, or the "we need to do better" all-hands. Those are real but hard to price, so we leave them off the table. The number is already uncomfortable.
4. LLM token burn for test generation
This is the new one, and it sneaks up on people. If you are using Cursor or Claude Code to write E2E tests for you, you are probably paying for it twice: once in subscription, once in the fact that AI-generated E2E tests usually do not work on the first try.
Hands-on reports line up on the shape of the problem: a coding agent often needs several attempts to produce a working end-to-end test for a non-trivial flow, and the harder the flow, the more attempts it takes. Each attempt burns tokens, and each failed attempt burns your time deciding whether to fix the prompt, fix the test, or give up. We broke this down in the real cost of LLM-driven test runs.
There is a deeper problem the token meter doesn't show. LLMs tend to write tests where they're easiest to write, not where regressions actually hide. So the specs you generate are both expensive to produce and biased toward the happy path, which is exactly the category of change a visual regression suite is supposed to catch and an LLM-written assertion usually doesn't.
Pricing this out: assume you generate or regenerate 2 tests per week, each taking an average of 4 attempts, each attempt consuming roughly 30k input + 5k output tokens at frontier-model rates. That lands around $15-30/month in raw API spend if you are not on a flat subscription, plus ~1 hour/week of prompt-wrestling.
52 hrs/yr × $75 = $3,900 (plus ~$250 in tokens if metered)
5. Context-switch cost
Every bug triage interruption costs more than the minutes it consumes. Interruption research has long put the cost of reclaiming focus at roughly 15 to 20 minutes per interruption. If bug triage interrupts you 3 times a week, that's:
3 × 20 min × 50 weeks = 50 hrs/yr × $75 = $3,750
6. Fully-loaded total
All six categories add up. Here is the per-developer annual view:
| Category | Hours/year | Annual cost (USD) |
|---|---|---|
| Test maintenance | 78 | $5,850 |
| CI reruns (human + compute) | 37 | $2,801 |
| Escaped incidents | 72 | $5,400 |
| LLM test generation | 52 | $4,150 |
| Context-switching | 50 | $3,750 |
| Total per developer | 289 | $21,951 |
Two hundred and eighty-nine hours. That's roughly 7 full work weeks per developer per year spent on QA work that was never in your job description. Scaled to a small team, it gets louder:
| Category | Hours/year | Annual cost at 5 devs (USD) |
|---|---|---|
| Test maintenance | 390 | $29,250 |
| CI reruns (human + compute) | 185 | $14,005 |
| Escaped incidents | 360 | $27,000 |
| LLM test generation | 260 | $20,750 |
| Context-switching | 250 | $18,750 |
| Team total | 1,445 | $109,755 |
A five-developer team is quietly burning the salary of a mid-level QA engineer every single year - except the money is distributed across every sprint, every 2am page, and every "wait, why is CI red again."
What actually moves the needle
Look at the table. The two biggest levers are test maintenance and LLM test generation. Together they account for over $10k per developer per year. If you can take those two to near-zero, you take back 130+ hours of your year. This is the same tax we measured from the other direction in the developer QA tax.
That's the bet behind Lastest: record a flow, get deterministic Playwright code back, and let a 7-layer self-healing selector system absorb the churn that normally eats your Fridays. The fallback chain runs data-testid, then id, role, aria-label, text, CSS, and finally OCR, so a refactor that renames a class does not turn into a broken test. No prompt engineering. No "regenerate the suite every time a div gains a class."
The key word is replay. AI runs only when you create or fix a test. Every run after that is plain Playwright execution, so you can run the suite thousands of times a day for $0 in tokens. That single property deletes most of the LLM-burn and rerun-stare line items above.
The visual regression side uses three diff engines, pixelmatch for pixel-perfect, SSIM for layout-aware, and Butteraugli for human-eye perceptual, so you catch the subtle rendering breaks that unit tests and LLM-written E2E specs systematically miss. That is the exact category of regression that quietly ships to production. Each failure is also auto-classified as a real regression, flaky, environment, or test-maintenance issue, with a confidence score, so the "wait, what broke?" stare gets shorter too.
The software cost column
Here's the part that matters for the spreadsheet: self-hosted Lastest is $0, forever, released under FSL-1.1-ALv2 and running on your own infrastructure. No seat licensing. No per-screenshot pricing. No vendor lock-in. Screenshots never leave your network. The repository lives at github.com/las-team/lastest. If you would rather skip the ops entirely, Cloud is a flat $299/month with no per-seat or per-screenshot fees, which still undercuts the per-run pricing models most visual-testing vendors charge.
So on the "cost of tooling" line, a team self-hosting Lastest pays $0 in software. The only costs are the CI compute you were already paying for, and those drop too because the self-healing selectors kill most reruns and the zero-token replays remove the per-run AI bill.
If you ship a Next.js app, a React app, or a Vue app, the record-and-replay flow works the same way. Open a recording session, click through the thing you want to protect, commit the generated spec. You bring your own AI provider (Claude, OpenAI, OpenRouter, or local Ollama), the MCP server exposes around 20 tools to your coding agent, and the Play Agent runs an 11-step pipeline so your AI assistant can operate the test suite instead of writing broken specs from scratch.
What to do on Monday
You do not need permission to run this experiment. Pick your three most-broken E2E tests - the ones you keep fixing. Replace them with recorded Lastest specs. Measure how many times they flake over the next two sprints compared to the same tests last quarter.
If the numbers above are even half right for your team, the payoff math is absurd. Even clawing back 30% of test-maintenance hours on a 5-developer team is $8,775/year. The tool is free. The downside is a Docker container.
You got handed the QA workload. You can at least stop paying for it twice. Self-host Lastest for free, browse the docs, or watch the demos first. The source is open at github.com/las-team/lastest, and if you want zero ops, Cloud is a flat $299/month. Either way, the per-run tax goes to zero.