Testing Framework Market Shifts: A 10-Year Timeline

Testing frameworks don't die overnight. They fade. Slowly at first, then all at once.

Over the last decade, the E2E testing space has gone through 3 distinct eras. Selenium owned the 2010s. Cypress disrupted it from 2017 to 2022. And Playwright now leads in npm downloads with over 34 million weekly installs as of early 2026 (npm trends).

But the transitions between these eras weren't clean. They overlapped. They were messy. And looking at a decade of data reveals patterns that quarterly snapshots miss entirely.

Era 1: The Selenium monopoly (2004-2017)

For over a decade, if you automated a browser, you used Selenium. There was no real alternative.

Here's the quick version of how that happened:

• 2004: Jason Huggins created Selenium Core at ThoughtWorks as an internal tool called "JavaScriptTestRunner" (Sauce Labs)

• 2006: Simon Stewart created WebDriver, a separate project using native browser drivers

• 2011: Selenium and WebDriver merged into Selenium 2.0 (July 2011), creating the architecture that testers still recognize today

• 2016: Selenium 3.0 launched (October 13, 2016), dropping Selenium RC and modernizing the codebase

Why Selenium dominated: No other tool offered multi-browser, multi-language automation. Browser vendors (Google, Mozilla, Microsoft, Apple) all shipped their own WebDriver implementations, giving Selenium a moat no competitor could match. The WebDriver API eventually became a W3C standard, which cemented Selenium's position as the industry default.

But Selenium had problems:

• Setup was painful.

• Tests were flaky.

• Debugging was a nightmare.

The gap between what developers wanted and what Selenium offered kept growing.

That gap is what created the opening.

Era 2: The Cypress disruption (2017-2022)

Cypress didn't just compete with Selenium. It rejected Selenium's entire approach.

Instead of controlling browsers through external drivers, Cypress ran tests inside the browser itself. This was a radical design choice, and it paid off with a developer experience that Selenium couldn't match.

Tip: Cypress's in-browser execution model gives it unique strengths (real-time reloading, time-travel debugging) but also inherent limitations (no multi-tab support, limited cross-browser coverage, JavaScript/TypeScript only).

What made Cypress resonate: It solved the developer experience problem. Setup took minutes, not hours. The interactive test runner showed tests executing in real time. And for frontend developers who already knew JavaScript, there was no new language to learn.

But cracks appeared. The Playwright vs Selenium vs Cypress comparison tells the full story, but here are the key friction points:

• Parallel execution required the paid Cypress Cloud service

• No native support for multiple browser tabs or windows

• Safari/WebKit support was limited

• JavaScript/TypeScript only, which shut out Java and Python teams

These limitations didn't matter when Cypress was the only modern option. They started to matter a lot when Playwright showed up.

The bridge: Puppeteer and Protractor (2013-2023)

These 2 frameworks deserve mention as transitional players. They didn't dominate, but they shaped what came next.

Puppeteer (2017): Google's Chrome DevTools team released Puppeteer as a Node.js library for Chromium automation (InfoQ, 2018). It was fast and simple. But it only worked with Chrome. The key engineers behind Puppeteer later moved to Microsoft and built Playwright, carrying their learnings with them. As of 2026, Puppeteer still pulls ~6.3M weekly npm downloads, largely for scraping and PDF generation rather than testing.

Protractor (2013-2023): Google built Protractor as the default E2E testing tool for Angular apps. It was included in Angular CLI, which guaranteed adoption. But Google stopped dedicating engineers to maintain it, and in April 2021, the Angular team announced plans to deprecate Protractor by the end of 2022. It was officially deprecated in August 2023. The Angular team recommended Cypress, WebdriverIO, and Playwright as replacements, and this exodus became a direct growth driver for all three.

Era 3: The Playwright takeover (2020-present)

Playwright's origin story starts at Google and ends at Microsoft.

The engineers who built Puppeteer brought a clear lesson with them: the Chrome DevTools Protocol (CDP) was faster and more reliable than WebDriver for browser automation. But Puppeteer was Chrome-only. Playwright's pitch was simple: build on the same foundation and make it work with every major browser.

Here's how it happened:

What drove the switch? The reasons show up clearly when you look at what teams were frustrated with:

• Free parallel execution: Built into the core, no paid service required

• True cross-browser: Chromium, Firefox, and WebKit from day one

• Multi-language: JavaScript, TypeScript, Python, Java, and C# support

• Auto-wait built in: Playwright checks that elements are attached, visible, stable, enabled, and receiving events before acting, which reduces flaky test failures significantly

• Microsoft backing: Consistent monthly releases, funded by one of the largest tech companies

ThoughtWorks Technology Radar tracked this progression. They first listed Playwright in the "Trial" ring, noting its stability and ease of migration from Puppeteer. By their latest assessment, they described Playwright as "the go-to test framework" and noted teams were migrating away from Cypress.

The State of JS 2024 survey confirmed the shift: Playwright led in satisfaction among E2E testing tools.

The download numbers, decade view

Here's where things stood at 3 key snapshots:

Source: npm trends

What stands out isn't just who's winning. It's the pace.

Playwright's growth curve is nearly vertical. Cypress's is flat. Selenium's is remarkably stable. And Puppeteer continues to hold steady, serving a different use case (automation/scraping) than the testing-focused tools.

Tip: npm download numbers capture only the JavaScript ecosystem. Selenium's true usage is much higher because its largest user bases are in Java (via Maven) and Python (via PyPI). Don't confuse npm-only data with total market share.

For a deeper look at how these numbers map to real-world testing framework adoption trends, the picture is more nuanced than raw downloads suggest.

Selenium 4 and the survival question

While Cypress and Playwright fought for the JavaScript-first crowd, Selenium quietly modernized.

Selenium 4.0 launched on October 13, 2021 with significant upgrades:

• Full W3C WebDriver compliance, replacing the JSON Wire Protocol

• Chrome DevTools Protocol (CDP) integration for advanced browser control

• Redesigned Selenium Grid with Docker and Kubernetes support

• Relative locators for more intuitive element targeting

Selenium isn't disappearing. It serves a different market. Enterprise teams with Java/Python/C# codebases, massive existing test suites, and a need for real mobile device testing (via Appium integration) still depend on it.

If you're maintaining a Playwright test suite alongside legacy Selenium tests, the question isn't "which is better." It's "which fits your team's stack."

Cypress in 2023-2026

Cypress didn't collapse. It plateaued.

After raising $54M+ through 2020, the company laid off employees in January 2023 as part of a broader restructuring. Reviews on Glassdoor from former employees describe internal challenges. Download growth flattened while Playwright's accelerated.

But ~6.5 million weekly npm downloads is still a massive number. Many teams have years of Cypress tests in production and no immediate reason to migrate. The framework continues to receive updates, and its developer experience for simple, single-browser frontend testing remains excellent.

What changed isn't that Cypress got worse. It's that the market's requirements expanded beyond what Cypress's architecture was designed to handle, and Playwright arrived to fill that gap.

For teams deciding between these tools, a detailed comparison of Playwright, Cypress, and Selenium can help clarify the trade-offs.

What's driving the current shift

3 forces accelerated Playwright's rise from 2023 onward:

1. GitHub Actions became the default CI. Academic research on CI service adoption found that GitHub Actions already exceeds 50% combined market share among repositories with CI. Playwright's native GitHub Actions support and built-in sharding for parallel execution made it the natural fit for this environment.
2. AI tooling favors Playwright. The rise of AI coding agents (GitHub Copilot, Claude Code, and Cursor) created a secondary adoption driver. Playwright's clean API and strong TypeScript support make it more compatible with AI-assisted test generation. The emergence of Playwright MCP and Playwright Skills for AI agents created a feedback loop: AI tools recommend Playwright, which increases adoption further.

3. The market is growing fast. The global automation testing market was valued at USD 35.52 billion in 2024 and is projected to reach USD 169.33 billion by 2034 at a 16.90% CAGR (Precedence Research, 2025). MarketsandMarkets estimated USD 55.2 billion by 2028 at 14.5% CAGR from a 2023 base of USD 28.1 billion. The variation reflects different market definitions, but the direction is the same: rapid growth, which benefits the framework best positioned for modern CI/CD workflows.

Tip: If your team is evaluating a framework switch, don't start with features. Start with your CI environment, your team's primary language, and your browser coverage requirements. These 3 factors predict framework fit better than any benchmark.

The pattern: What a decade of data shows

Zoom out, and you can see a repeating cycle.

Every major testing framework follows a similar arc:

• Pain creates demand. Selenium's flakiness created the opening for Cypress. Cypress's limitations created the opening for Playwright.

• Developer experience wins adoption. Cypress beat Selenium on DX. Playwright beat Cypress on DX + capability breadth.

• Corporate backing matters. Cypress had VC funding. Playwright has Microsoft. Selenium has the W3C. Frameworks without institutional support (Protractor, TestCafe) tend to stall.

• The "previous generation" doesn't vanish. Selenium didn't die when Cypress rose. Cypress isn't dying as Playwright rises. Installed bases create inertia that lasts years.

The next disruption probably won't come from a faster Selenium alternative. It'll come from a fundamentally different approach to testing, likely AI-native, where tests are generated, maintained, and healed without manual scripting.

For tracking your test suite's health across framework transitions, tools like TestDino provide AI-powered reporting and analytics for Playwright that help teams measure stability.

Framework Timeline at a Glance

What comes next

The next shift won't be about which framework runs tests faster. It'll be about which framework writes and maintains tests for you.

3 trends are already taking shape.

1. AI-native testing is no longer theoretical

Playwright shipped Agents in 2025/2026, with 3 built-in agent definitions that guide LLMs through test creation:

• Planner: Explores your app and produces a Markdown test plan

• Generator: Converts that plan into Playwright test files

• Healer: Runs the suite and automatically repairs failing tests

You set it up with a single command:

npx playwright init-agents --loop=vscode

(or --loop=claude for Claude Code). This isn't a third-party plugin. It's a first-party feature from the Playwright core team.

2. MCP bridges AI and test data

MCP (Model Context Protocol) is quietly connecting the pieces that make AI-native testing work end to end.

Here's the loop:

• Playwright MCP lets AI agents browse pages, click elements, fill forms, and extract structured data from browsers

• TestDino MCP lets AI agents query test results, failure classifications, and flaky test patterns directly

• AI writes tests → the framework runs them → reporting tools feed results back to AI for maintenance and improvement

This feedback loop didn't exist a couple of years ago. It's operational now.

Tip: If you're evaluating AI testing workflows, look for tools that expose test data through MCP or similar protocols. An AI agent that can generate tests but can't see historical failure patterns is only solving half the problem.

3. The framework itself might become invisible

Here's the question nobody's asking yet: if AI handles test generation, execution, and maintenance, does the average QA engineer care whether Playwright or Cypress runs under the hood?

Probably not.

The winning layer shifts from "which framework" to "which intelligence platform sits on top."

The framework becomes infrastructure, like how most developers don't think about which HTTP server their API runs on, testers may stop thinking about which browser automation library runs their tests.

That's not a 2026 reality. But if current trends in AI agent tooling hold, it's a 2028 conversation.

For now, the practical move is to pick a framework with strong AI tooling support (Playwright leads here), pair it with reporting that classifies failures automatically, and build workflows that close the feedback loop between test execution and test maintenance.

FAQs