Originally published at devtoolpicks.com
Here's a thing that surprises people: choosing an end-to-end testing framework in 2026 is way less of a debate than the internet makes it sound. For a solo founder building a web app on a JavaScript, TypeScript, or Python stack, running tests in GitHub Actions, watching CI minutes, the answer is mostly settled. But the comparison articles haven't caught up, so you'll read endless three-way debates that matter for a 50-person enterprise QA org and not for you.
Let me cut through it. All three of these are free and open source. So stop comparing license fees, because there aren't any. The real cost of end-to-end testing is CI minutes, the hours you'll burn debugging flaky tests, and whether you can actually test Safari. That's the lens that matters for an indie hacker, and through that lens the picture is clear.
Playwright has become the default for new projects, and the data backs it up: it pulls far more weekly npm downloads than Cypress and Selenium combined, sits around 88,000 GitHub stars, and topped the latest State of JS satisfaction survey by the widest margin yet. But "most popular" isn't a reason on its own. Here's what each one actually does well, what it costs you in practice, and who should still pick the other two.
The Quick Verdict
| Tool | Best for | Real cost | Browsers |
|---|---|---|---|
| Playwright | The default for new web projects | CI minutes only, free parallel | Chromium, Firefox, WebKit (Safari) |
| Cypress | Frontend DX on single-domain apps | Free, but parallel pushes you to paid Cloud | Chromium, Edge, Firefox (experimental) |
| Selenium | Legacy suites, polyglot, native mobile | Grid infrastructure | All, including legacy via WebDriver |
Short version: start new projects on Playwright. Use Cypress only if its developer experience is the thing you care about most and you live within its limits. Reach for Selenium if you already run it, your team isn't on JS or Python, or you need real mobile-device testing.
They're All Free, So What Actually Costs You?
This is the section nobody leads with. Since none of the three charge a license fee, your spend is downstream: CI compute, maintenance time, and any dashboard subscription.
Playwright's parallelization is free and built in. You split a suite across runners with a single --shard flag, no extra service required. Independent estimates put a 500-to-1,000-test suite on GitHub Actions around $150 to $300 a month in CI minutes with Playwright.
Cypress is where it gets subtle. The framework is free, but its parallel execution and the reporting dashboard run through Cypress Cloud, which is paid. After Cypress was acquired in 2025, the free Cloud tier was capped (roughly 30-day data retention and a yearly test-result limit), with the Team plan landing around $67 a month beyond that. So a Cypress suite can cost meaningfully more to run at the same scale, both in CI minutes and the Cloud subscription you drift into.
Selenium has no subscription, but parallel runs need a Grid, either self-hosted (real infrastructure to maintain) or through a paid service like BrowserStack. That's the most operational overhead of the three.
The other hidden cost is flakiness. A flaky test you re-run three times burns CI minutes and, worse, your trust in the suite. Playwright's auto-wait engine retries actions intelligently, and independent benchmarks show it producing dramatically fewer flaky failures than Selenium's manual waits. For a solo dev, fewer 11pm "why did CI fail again" sessions is worth more than any benchmark.
Playwright
Playwright is the one I'd start any new project on. Microsoft released it in 2020, built by the team that originally created Puppeteer, and it talks to browsers directly through their native debugging protocols rather than through a middleman driver. That architecture is why it's fast and why it auto-waits for elements instead of making you write manual waits.
The practical wins stack up. It drives Chromium, Firefox, and a real WebKit engine, so you test actual Safari behavior on any OS, including a Linux CI runner, with zero setup. It handles multi-tab, multi-origin, and iframe flows natively, which matters the moment you test an OAuth login or a Stripe checkout popup. It supports TypeScript, JavaScript, Python, Java, and C#, ships a codegen recorder, traces, and screenshots, and parallelizes for free. It even tests API routes and server components directly, which pairs well if you're building on Next.js, Nuxt, or SvelteKit, and it overlaps neatly with the API-layer tools I covered in the best API testing tools.
For an indie hacker leaning on AI, Playwright also has the best agent story: a Playwright MCP server, a recorder that generates tests, and "Fix with AI" in the VS Code extension. If you already pair with an AI coding tool, this is the framework that plugs into that workflow most cleanly. It's also what Checkly uses under the hood for synthetic monitoring, which I touched on in the best uptime monitoring tools.
Who should skip it? If you need to automate native iOS or Android apps, Playwright only emulates mobile browsers, so you'll want Appium instead. Its plugin ecosystem is younger than Selenium's two-decade base, though it has replicated most of that functionality with built-in APIs. And if your team genuinely lives and dies by Cypress's interactive runner, the switch is a real adjustment.
Cypress
Cypress earned a devoted following for one reason: developer experience. It launched in 2017 with a genuinely novel idea, running your test code inside the browser in the same event loop as your app. That gives you the time-travel debugger, the interactive test runner where you watch each command replay, and deep access to your app's internals. For a frontend developer who wants tight, visual feedback while writing tests, nothing else feels as good. Its component-testing story is also the most mature of the three, covering the widest range of frontend frameworks. The current line is Cypress 15, which recently added an AI-assisted authoring command in beta.
But the architecture that makes Cypress pleasant also boxes it in, and the limits are exactly the things indie SaaS apps hit. There's no real Safari support: Chromium and Edge are first-class, Firefox has been experimental for years, and WebKit isn't there. With Safari at roughly 18% of browsers, that alone disqualifies Cypress as a sole testing tool for many consumer apps. It also can't do true multi-tab flows, because the runner itself occupies the second browser slot. The cy.origin() command handles some cross-origin OAuth in a single tab, but popups and real multi-tab interactions are out. That multi-tab gap is the single most common reason teams migrate to Playwright in 2026.
Who should skip it? Anyone who needs Safari coverage, multi-tab flows, or a non-JavaScript language, which rules it out for a lot of real apps. And anyone cost-sensitive about CI, since free parallelization isn't part of the picture. If you're a pure JS or TS team on a single-domain SPA and the DX is what keeps you actually writing tests, Cypress is still a legitimate, even excellent, choice. The best framework is the one your team uses consistently.
Selenium
Selenium is the grandparent of browser automation, open source since 2004, and it's still here for good reasons. It has the largest installed base of any framework, the broadest language support (Java, Python, C#, Ruby, PHP, JavaScript, Kotlin), and the widest browser coverage including legacy targets. It's actively maintained, not a museum piece: Selenium 4.43 is current, and Grid 4.41 added native Kubernetes provisioning in early 2026, with expanding WebDriver BiDi support that modernizes how it talks to browsers.
Its real superpower for 2026 is the one thing the other two can't do: paired with Appium, Selenium drives true native mobile apps on real iOS and Android devices, not just mobile browser emulation. If your product is a native app, the Selenium and Appium combination is the industry standard.
Who should skip it? Most new indie web projects, honestly. Selenium uses the WebDriver protocol, which puts a driver process between your test and the browser and adds round-trip latency on every command, so it's the slowest of the three. It has no native auto-wait, so you write explicit waits and fight more flakiness. And parallelizing means standing up a Grid, which is real infrastructure. For a solo founder on a modern JS or Python web stack, that's a lot of overhead to take on Selenium's breadth when you'll use a fraction of it. Pick it for an existing suite, a polyglot team, or native mobile, not for a greenfield web app.
How Do the Three Compare Head to Head?
Strip it to the dimensions that decide a real project.
| Dimension | Playwright | Cypress | Selenium |
|---|---|---|---|
| Speed | Fastest | Fast | Slowest |
| Flakiness | Lowest (auto-wait) | Low | Highest (manual waits) |
| Safari/WebKit | Yes | No | Yes |
| Multi-tab flows | Yes | No | Yes |
| Free parallel | Yes | No (Cloud) | Via Grid |
| Languages | TS, JS, Python, Java, C# | JS/TS only | Most languages |
| Native mobile | No | No | Yes (Appium) |
The pattern is clear. Playwright covers the things that matter for a modern web app with the least friction. Cypress trades coverage for developer experience. Selenium trades speed and setup for unmatched breadth.
How Do You Choose the Right One?
Start with your stack and what you actually need to test.
Concrete scenarios. Brand-new SaaS on a JS, TS, or Python stack? Playwright, almost every time. Testing a native mobile app? Selenium with Appium. Frontend team on a single-domain SPA that genuinely loves the Cypress runner and doesn't need Safari? Cypress is fine. Big legacy Selenium suite that works? Don't rewrite it for fun, just write new coverage in Playwright alongside it.
The Verdict: Which Should You Use?
For almost every new indie project in 2026, use Playwright. It's free, it's the fastest and least flaky of the three, it tests every browser including Safari, it parallelizes without a paid dashboard, and it has the best AI tooling if you build with coding agents. The popularity is a symptom, not the reason. The reason is that it removes the exact friction (flaky tests, Safari gaps, paid parallelization) that wastes a solo dev's time and money.
Choose Cypress only if its developer experience is genuinely the thing that makes you write tests, your app is single-domain, and you don't need Safari or multi-tab flows. That's a narrower box than it used to be, but inside it, Cypress is still a joy.
Choose Selenium if you already run it and it works, your team isn't on JavaScript or Python, or you need real native mobile testing through Appium. It's not the default for new web projects anymore, but it's far from dead and it's the right tool for those specific jobs.
The honest meta-point is that the framework war that dominates the search results is mostly an enterprise conversation. For a solo founder shipping a web app, the decision compresses to one line: use Playwright unless you have a specific reason rooted in mobile, language, or an existing suite. Spend the time you saved writing actual tests. Running one of these on your project? Tell me how it's going on @devtoolpicks.
Top comments (0)