Your QA engineer left. Or you never had one. Either way, the test pyramid is now on your desk, and the sprint is still moving. This Playwright vs Cypress vs Testing Library battlecard is for developers who got QA workload dumped on them and need to pick a tool in an afternoon, not a quarter.
We will compare the four tools you are most likely to reach for: Playwright, Cypress, Testing Library (with Jest or Vitest), and Lastest (that is us, hi). We are going to be fair. Each of these tools is good at something. But the dev-doing-QA use case has a very specific shape, and not every tool fits it.
The shape of the dev-doing-QA problem
You are not a full-time tester. You have maybe four hours a week to give to QA before your actual tickets start slipping. You need tests that:
- Catch regressions in the flows that matter to users, not just the ones that are easy to write.
- Do not break every time someone renames a CSS class or reorders a div.
- Run in CI without costing more than the engineer who would have written them.
- Can be authored, updated, and debugged without a PhD in async timing.
Once a suite passes fifty tests, E2E maintenance tends to eat the better part of a sprint day per developer per month. That is real time, gone, every month, per person, before you write a single feature. The tool you pick decides whether that number holds steady or compounds.
The contenders, briefly
Playwright is Microsoft's cross-browser automation framework. Fast, modern API, excellent debugging tools, runs Chromium, WebKit, and Firefox. The de-facto winner of the 2024-2025 E2E wars.
Cypress is the developer-experience pioneer. Time travel, interactive runner, component testing, massive plugin ecosystem. Still extremely popular, especially on teams that started with it years ago.
Testing Library (React Testing Library, Vue Testing Library, etc.) runs inside Jest or Vitest. It is not really an E2E tool, it is a component/integration tool, but many dev-doing-QA situations start here because the setup is already in the repo.
Lastest is what we build: free and self-hosted under FSL-1.1-ALv2. Record a flow in your browser, get deterministic Playwright code out, and replays cost zero AI tokens because AI runs only when you create or fix a test. Seven-layer self-healing selectors, three visual diff engines, an MCP server with roughly 20 tools, and a Play Agent that repairs broken tests automatically. docker-compose up and you are running. Source at github.com/las-team/lastest.
The battlecard
Here is the head-to-head on the dimensions that matter when QA is a side quest. Numbers are order-of-magnitude estimates from public benchmarks, community surveys, and our own measurements. Your mileage will vary, but not by an order of magnitude.
| Dimension | Playwright | Cypress | Testing Library | Lastest |
|---|---|---|---|---|
| Setup time (zero to first green test) | 30-60 min | 20-45 min | 10-20 min (if Jest/Vitest already wired) | 5-10 min (docker-compose up, record flow) |
| Typical flake rate | 2-5% with auto-wait, higher on XHR-heavy apps | 3-7%, worse on cross-origin flows | <1% (it is a unit-test runner, not a browser) | 1-3% (self-healing absorbs most transient selector drift) |
| Maintenance hours / month / dev | 5-8 hrs | 6-9 hrs | 3-5 hrs (smaller surface, but does not catch real regressions) | 1-2 hrs (Play Agent auto-repairs, selector fallback chain) |
| Visual regression | Built-in screenshot compare (pixelmatch-like), no SSIM/perceptual by default | Via paid Percy or Applitools integration | Not supported (no real rendering) | Three engines bundled: pixelmatch, SSIM, Butteraugli |
| Cost at CI scale (500 tests, 20 runs/day) | Free (OSS), but CI minutes add up; ~$80-150/mo on GitHub Actions | Free OSS + Cypress Cloud $75-300/mo for parallelization | ~$20-40/mo (fast, no browser) | Free, self-hosted, parallelizes on your own runner |
| Who writes the test | You (hand-coded) or an LLM with 3+ retries | You, or the Cypress Studio recorder (limited) | You, every time | You click through once, Lastest generates Playwright code |
| What breaks on UI refactor | CSS selectors, text matchers; you fix by hand | Same; recorder output is especially brittle | Depends on queries; getByRole is resilient, getByTestId is not if testids change |
7-layer fallback retries via data-testid -> id -> role -> aria -> text -> css -> OCR before failing |
Where each tool actually shines
Playwright: the engineer's choice
If you have the time and taste to hand-author E2E tests, Playwright is the best tool in the category. The API is clean, the trace viewer is phenomenal for debugging, and cross-browser support is real, not theoretical. We literally generate Playwright code as Lastest's output because we think it is the right engine.
Where Playwright struggles for the dev-doing-QA case is authoring speed. You still have to write the test. And if you point a raw LLM at the job, you tend to get plausible-looking selectors that drift from the live DOM, so it takes several rounds of run-fix-rerun before a spec goes green. That is not zero-effort; that is babysitting an intern. The fix is not a smarter prompt, it is grounding the agent in a real browser, which is exactly what the Lastest MCP server does.
Cypress: the DX pioneer, fading on modern stacks
Cypress's interactive runner is still a joy. If your team already knows Cypress and your app is single-origin, keep using it. Where it struggles: iframes, multi-tab flows, cross-origin authentication, and the licensing math on Cypress Cloud once you want parallelization. Cypress Studio (the recorder) exists, but the output is brittle in practice and tends to bake in selectors that break the moment a designer touches the page.
Testing Library: great tool, wrong job
Here is the honest take. Testing Library is excellent. getByRole queries push you toward accessible markup, tests run in milliseconds, and there is almost no flake because there is no browser. If you are shipping a design system or a utility library, this is what you want.
But if you are the dev-doing-QA, your job is usually to catch regressions in real user flows: login, checkout, dashboard, settings. Testing Library runs in jsdom. It does not load your real CSS, does not fire real network requests, does not render like a real browser. You can mock all of that, but now you are maintaining a simulation, not testing the app. There is a well-known bias here: tests get written where they are easiest, not where regressions actually hide. It is genuinely easy to rack up hundreds of green component tests and still ship a broken checkout.
So which do you actually pick? (The axis error nobody names)
Here is the reframe most "Testing Library vs Playwright" posts miss: it is partly an axis error. Testing Library tests component logic and behavior - unit and integration, in jsdom, with no real browser. Playwright tests real user flows end-to-end in an actual browser. Those are different jobs, so the honest answer is usually "both," not "either." But notice what they share: both produce true/false functional assertions. Both leave the entire visual layer untested. Neither one catches a layout that breaks, a container that overflows, a wrong brand color, or a money value that renders as $124000 instead of $1,240.00 - because a value that is technically present still passes toBeVisible() while looking completely wrong to a human.
Lastest is not a fourth competitor on that same axis. It sits on top of Playwright - it runs plain Playwright under the hood - and adds the layer neither tool sees: pixel verification instead of a binary assert. Where an assertion answers yes/no, Lastest's three diff engines return one of three verdicts - unchanged, flaky, or changed - routed to a review dashboard for a human call, backed by 7-layer self-healing selectors and visual diffing that catches what assertions cannot. So the practical stack is: Playwright for flows, Testing Library for component logic, and Lastest for the visual layer neither one sees. Because replays are plain Playwright, they cost zero AI tokens - AI runs only when you create or fix a test, never on the thousands of reruns.
Not "Testing Library or Playwright or Lastest." Keep the suite you have, add the pixel layer on top. Try it free: self-host in ten minutes, spin up Lastest Cloud, or watch live demos first.
Lastest: built for the time-starved developer
Our bet is simple. If you got QA dumped on you, the constraint is not tooling quality, it is your hours. So we optimize for two numbers: time to first test and maintenance hours per month.
You open Lastest, click through the flow you care about the same way a user would, and we generate deterministic Playwright code. Not a recording that replays mouse coordinates, actual code, with selectors ranked by stability. You choose how much AI you want: AI-Free recording (air-gapped, no API keys), AI-Assisted (AI proposes, you review every change), or Full Autonomous via the Play Agent. When the UI refactors, the 7-layer self-healing chain retries each selector strategy in order before the test fails. If it does fail, the Play Agent's 11-step pipeline attempts a repair and proposes a diff for you to review. AI never approves its own work; you render one of three verdicts.
Visual regression is bundled, not a paid add-on. You get three engines: pixelmatch for strict pixel diffs, SSIM for structural similarity that ignores anti-aliasing noise, and Butteraugli for perceptual diffs that match what a human eye would actually notice. Every failure is auto-classified as real regression, flaky, environment, or test-maintenance with a confidence score, and every screenshot gets a WCAG 2.2 AA score from axe-core. Smart Run reads your git diff and runs only the tests your change touches, so CI stays fast.
For AI workflows, the Lastest MCP server exposes roughly 20 tools, so your coding agent can author, run, and repair tests against a real browser instead of hallucinating selectors. Bring your own AI provider too: Claude, OpenAI, OpenRouter, or local Ollama, with no lock-in. It is free, self-hosted, FSL-1.1-ALv2 licensed, and lives at github.com/las-team/lastest. docker-compose up is the whole install.
Decision guide: which should you pick?
Different tools, different pains. Here is how we would call it:
- You have a dedicated QA engineer and taste for hand-crafted tests: Playwright. No contest.
- Your team is already deep in Cypress and your app is single-origin: stay on Cypress. The switching cost is not worth it.
- You ship a component library or design system: Testing Library plus Vitest. Fast, focused, correct.
- You are one developer, you inherited QA, and you need to move this week: Lastest. Record the flow, ship the test, let the self-healing selectors and Play Agent absorb the maintenance tax.
- You already have a Playwright (or Testing Library) suite and just want to stop shipping visual bugs: keep it, and add Lastest on top for the pixel layer. It runs your existing Playwright under the hood, so it complements rather than replaces. See the full feature list or start on Lastest Cloud.
If you are on Next.js, React, or Vue specifically, we have setup guides that take you from zero to CI-green in under fifteen minutes: Next.js, React, Vue.
The honest summary
If you measured these four tools only on test-authoring elegance, Playwright wins. If you measured them only on developer experience circa 2020, Cypress wins. If you measured them only on speed, Testing Library wins.
But the dev-doing-QA scorecard is different. The only numbers that matter are how long before the first test runs green and how many hours a month you spend fixing tests instead of shipping features. On those two axes, Lastest is built to win by construction, because every design decision (the recorder, the 7-layer fallback, the Play Agent, the bundled visual diffs) exists to push those numbers down.
You can try it in about ten minutes. git clone, docker-compose up, record a flow, commit the generated Playwright test. If you hate it, you still have hand-written Playwright code in your repo and you have lost nothing. If you love it, you just got your sprint day back.
Self-host it free, forever (FSL-1.1-ALv2, unlimited screenshots and replays on your infra) from github.com/las-team/lastest, or skip the ops and run it on Lastest Cloud at $299/month flat with no per-seat or per-screenshot fees. Browse the live demos, read the docs, or jump straight to the dev-doing-QA guide.
The one-line takeaway if you skimmed: Playwright and Testing Library both answer "did it work?" - neither answers "does it still look right?" Lastest is the pixel layer that does, and it rides on top of the Playwright you already trust. Point it at your app, keep every existing test, and let three diff engines plus a review dashboard catch the visual regressions your assertions were never going to see. Self-host free → · Start on Cloud → · See a real diff →
QA that does not eat your sprint. Record once, self-heal forever, ship on Friday.