Playwright vs Selenium: is Selenium still worth learning in 2026?

Selenium or Playwright: which should you learn in 2026?

In 2026, learn Playwright before Selenium: a Playwright course then leaves you able to understand Selenium. The question “Selenium or Playwright” comes up with almost every candidate retraining in software testing, often with a worry: “if I learn Playwright, will I miss the job offers that ask for Selenium?”. Here is our position, argued in the rest of this page. To get started, follow our Playwright guide.

• To learn the profession: Playwright. It gets you working straight away on good practices (semantic locators, auto-waiting, traces, CI) without having to assemble a runner, an assertion library and a driver manager yourself.
• To join a team that already has thousands of Selenium tests: you need to be able to read, maintain and run that suite. This is learned in a few days once you already master the concepts with Playwright, because the vocabulary is shared.
• For a very specific need (Internet Explorer, Ruby or Kotlin, an existing Selenium Grid infrastructure), Selenium remains the rational choice. The official documentation lists Chrome, Edge, Firefox, Internet Explorer and Safari, and examples in Java, Python, C#, Ruby, JavaScript and Kotlin (source: selenium.dev, accessed 27 September 2026).

A stand-alone “Selenium course” in 2026 is therefore not the best entry point for changing careers. A Playwright course that leaves you able to understand Selenium is: that is the purpose of our certified Playwright course (FR) (40 h, 100% online).

Selenium and Playwright: how are they positioned?

Selenium positions itself as an umbrella project at the origin of the W3C WebDriver standard, whereas Playwright positions itself as an integrated test framework, maintained by Microsoft.

Selenium: an umbrella project that became a standard

Selenium describes itself as “an umbrella project for a range of tools and libraries that enable and support the automation of web browsers” (source: selenium.dev, accessed 27 September 2026). Three main components structure the offering:

• Selenium WebDriver, “an interface to write instruction sets that can be run interchangeably in many browsers”; this is the core of the project;
• Selenium Grid, to run tests “in parallel across multiple machines”;
• Selenium IDE, “a browser extension that records and plays back a user's actions”.

Added to these is Selenium Manager, a command-line tool that automatically manages drivers and browsers, used by default by the bindings (source: selenium.dev, accessed 27 September 2026). The key point of the positioning: the project implements the W3C WebDriver specification, which produces “interchangeable code for all major browsers”. Selenium is not just a tool; it is the origin of a web standard.

Playwright: an integrated test framework

Playwright presents itself as “an end-to-end test framework for modern web apps” that “bundles test runner, assertions, isolation, parallelization and rich tooling”, maintained by Microsoft (source: playwright.dev, accessed 27 September 2026). The difference in philosophy is clear: Selenium provides a browser-driving interface and leaves the ecosystem (JUnit, pytest, TestNG, assertion libraries, report managers) to complete the rest; Playwright delivers everything in a single package.

For a beginner, this difference is not a detail. With Selenium, the first day often consists of choosing and assembling five tools. With Playwright, npm init playwright@latest installs the runner, the configuration and a first test (source: playwright.dev, accessed 27 September 2026).

How do Selenium and Playwright drive the browser?

Selenium drives the browser through the W3C WebDriver specification and a driver specific to each browser, whereas Playwright directly drives browser builds that it installs itself, without WebDriver drivers.

The WebDriver model

Selenium WebDriver relies on the W3C WebDriver specification: the test sends standardised commands to a driver specific to each browser, which translates them for that browser (source: selenium.dev, accessed 27 September 2026). This is what guarantees interchangeability between Chrome, Edge, Firefox, Internet Explorer and Safari, and it is what allowed Selenium to cover older and recent browsers alike. The documentation also mentions support for BiDi (bidirectional protocol) and an integration with the Chrome DevTools Protocol for logging, network monitoring and script execution (source: selenium.dev, accessed 27 September 2026).

The Playwright model

Playwright does not use WebDriver drivers. It directly drives browser builds that it installs itself: “Chromium (open source builds)”, a Firefox “patched version matching Firefox Stable” and a WebKit “derived from latest WebKit main branch, not Safari”. It can also use the branded Google Chrome and Microsoft Edge channels. In return, it “doesn't work with the branded version of Firefox” or with the commercial Safari (source: playwright.dev, “Browsers” page, accessed 27 September 2026).

What this changes day to day

• Installation. Playwright: npx playwright install downloads the three engines. Selenium: Selenium Manager now manages drivers and browsers automatically, which greatly simplified a historically painful step (source: selenium.dev, accessed 27 September 2026).
• Coverage. Selenium tests the real installed browsers, including Internet Explorer and Safari. Playwright tests rendering engines (Chromium, patched Firefox, WebKit) and official Chrome/Edge channels, plus native mobile emulation for Chrome Android and Mobile Safari (source: playwright.dev, accessed 27 September 2026).
• Isolation. Playwright includes isolation in what its runner “bundles” (source: playwright.dev, accessed 27 September 2026): each test starts in a clean context. With Selenium, isolation is a discipline for the team (new session, state clean-up).

Which languages do Selenium and Playwright support?

Selenium supports six languages (Java, Python, C#, Ruby, JavaScript and Kotlin) and Playwright four (Node.js in JavaScript/TypeScript, Python, Java and .NET), according to their official documentation (sources: selenium.dev and playwright.dev, accessed 27 September 2026). If your team works in Ruby or Kotlin, Selenium is the only one of the two that is officially documented.

For a career change, what matters is not the number of languages but the one you will learn first. At AutomationDataCamp, it is TypeScript with Playwright: typing that catches errors before execution, a Node ecosystem that is ubiquitous in web teams, and a syntax that reads almost like the test scenario. The same test, in Selenium Java, as it is found in many companies:

WebDriver driver = new ChromeDriver();
driver.get("https://exemple.fr/login");
driver.findElement(By.id("email")).sendKeys("qa@exemple.fr");
driver.findElement(By.id("password")).sendKeys("secret");
driver.findElement(By.cssSelector("button[type=submit]")).click();
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(ExpectedConditions.visibilityOfElementLocated(By.tagName("h1")));
driver.quit();

And in Playwright TypeScript:

import { test, expect } from '@playwright/test';

test('connexion réussie', async ({ page }) => {
  await page.goto('/login');
  await page.getByLabel('E-mail').fill('qa@exemple.fr');
  await page.getByLabel('Mot de passe').fill('secret');
  await page.getByRole('button', { name: 'Se connecter' }).click();
  await expect(page.getByRole('heading', { name: 'Tableau de bord' })).toBeVisible();
});

Two lines disappear in the Playwright version: the explicit wait and the closing of the browser, both handled by the runner. These are precisely the two most frequent sources of errors among Selenium beginners.

Playwright or Selenium: which limits flaky tests better?

Playwright limits flaky tests more thanks to its auto-waiting, whereas with Selenium the waiting strategy is written and maintained by the team. A “flaky” test fails or passes without the code under test having changed. The number one cause, in web automation, is synchronisation: the test acts on an element that is not yet displayed, not yet enabled or still animating.

What Playwright does for you

Playwright documents “auto-waiting” and “web-first assertions”: before clicking, it waits for the element to be present, visible, stable and enabled; an assertion such as toBeVisible() retries up to a maximum timeout instead of failing immediately. The runner adds configurable retries and the Trace Viewer, which records every action so you can understand a failure after the fact (source: playwright.dev, accessed 27 September 2026).

What Selenium asks you to write

The home page of the Selenium documentation highlights W3C interoperability and the project's components; it does not present an equivalent auto-waiting mechanism at the WebDriver API level (source: selenium.dev, accessed 27 September 2026). In practice, the waiting strategy (explicit, conditional) is written and maintained by the team, as in the Java example above. Done well, it works perfectly; done badly, it produces Thread.sleep() calls that slow everything down and guarantee nothing.

This is the central teaching argument in favour of Playwright for beginners: you first learn what a correct wait is, because the tool gives you the model, before ever having to rewrite it yourself in a Selenium codebase.

Why does Selenium still dominate in the enterprise?

Selenium still dominates in the enterprise, where it keeps a clear lead, for three reasons: Selenium Grid, the weight of Java and legacy browsers.

Selenium Grid

Grid makes it possible to run tests “in parallel across multiple machines” (source: selenium.dev, accessed 27 September 2026). Many companies have invested in a Grid infrastructure, in-house or with a cloud provider, and will not replace it overnight. Playwright parallelises across the workers of a single machine or CI runner, which is enough for most teams, but does not replace a grid of heterogeneous real browsers that is already in place.

The weight of Java

In banking, insurance, industry or the public sector, UI test suites are often written in Java, with JUnit or TestNG, and integrated into Jenkins pipelines. Playwright exists for Java (source: playwright.dev, accessed 27 September 2026), but the installed base of Selenium Java is considerable and represents years of work. A rational team does not rewrite ten thousand tests that work.

Legacy browsers

Selenium lists Internet Explorer among the supported browsers (source: selenium.dev, accessed 27 September 2026). As soon as an internal system still requires that browser, Selenium is the de facto tool.

What this means for you: do not dismiss job offers that mention Selenium. A solid Playwright profile who can read a Selenium suite, understand its waiting model and run it in CI is a credible candidate for these roles. This is exactly what we aim for in the ADC programme: a Playwright foundation, a critical reading of Selenium.

Playwright vs Selenium: what are the differences in one table?

The differences between Playwright and Selenium are summarised in the table below, each row of which is based on the official documentation accessed on 27 September 2026 (playwright.dev, selenium.dev). Where a piece of information was not there, we say so.

When does Selenium remain the right choice?

Selenium remains the right choice in the situations below, where we recommend it without hesitation: it would be dishonest to present it as outdated.

• A large, stable existing suite. The value of a test suite lies in its coverage, not in its tool. If it runs, you maintain it.
• A language outside Playwright's scope. Ruby and Kotlin are documented on the Selenium side, not on the Playwright side (sources: selenium.dev and playwright.dev, accessed 27 September 2026).
• Internet Explorer or specific installed browsers. The WebDriver model tests the browser actually present on the machine, including Internet Explorer (source: selenium.dev, accessed 27 September 2026).
• A Selenium Grid infrastructure that has already paid for itself, in-house or with a provider.
• A requirement to comply with a standard. Some organisations mandate the W3C WebDriver protocol in their tooling frameworks.

In all these cases, the right strategy is coexistence: Playwright for new scopes and API tests, Selenium for what already exists, with a shared CI pipeline.

Playwright or Selenium: what should you learn for a career change?

When changing careers, learn Playwright and TypeScript before Selenium, after the ISTQB CTFL v4.0 fundamentals: this is the order we apply in the “QA Automation & AI Tester” programme (399 hours, 12 weeks, 100% online, no prerequisites), and here is why.

1. Testing fundamentals, with ISTQB CTFL v4.0. Before any tool, understand what you are testing, why and how to prioritise it. The CTFL exam is included in the programme (second attempt offered). See the dedicated CTFL certification page.
2. Playwright and TypeScript. Semantic locators, auto-waiting, fixtures, multi-browser projects, Trace Viewer. This is the core of the technical foundation, and it transfers to Selenium afterwards.
3. API testing with the same runner. An automation tester who can only test the UI is incomplete. See the API testing course (FR).
4. GitHub Actions CI. Every suite runs in a pipeline from the first weeks, with reports and traces as artefacts.
5. A guided reading of Selenium. Understand WebDriver, explicit waits and Grid, so you are operational on an existing suite without fearing it. This is enough for the vast majority of offers that “ask for Selenium”.
6. AI applied to testing and ISTQB CT-GenAI v1.1. AI-assisted test case generation, script review, failure analysis, with the safeguards of the ISTQB syllabus. The exam is included (second attempt offered). See AI in software testing.

On completion, you obtain the ADC Professional Certificate CP-QAI, in addition to the two ISTQB certifications if you pass the exams. It all takes place in evening classes with a mentor, at €1,500 in 1 to 4 instalments, or full time funded by the employer. The next session runs from 15 October 2026 to 15 January 2027, with 12 places; registration is possible until 22 October. The full pathway is described on becoming a software tester.

Frequently asked questions about Playwright vs Selenium

Is Selenium dead in 2026?

No. Selenium is an active project, built on the W3C WebDriver specification, with bindings in six languages and support for BiDi and the Chrome DevTools Protocol (source: selenium.dev, accessed 27 September 2026). Its installed base in enterprise remains very large. What has changed is the best entry point for learning the profession: Playwright.

Do you need a Selenium course to find a job as a tester?

Not necessarily. A course that makes you autonomous on Playwright, API testing and CI, and that includes a guided reading of Selenium, also prepares you for roles that mention Selenium. Recruiters look for testers able to understand and maintain an existing suite, not specialists in a single syntax.

Does Playwright replace Selenium Grid?

Not one-for-one. Playwright parallelises across the workers of a single machine or CI runner, which covers most needs. Selenium Grid distributes tests across several real machines (source: selenium.dev, accessed 27 September 2026). If a Grid already exists, it keeps its value for installed and heterogeneous browsers.

Does Playwright test the real Safari?

No: it drives a WebKit build “derived from latest WebKit main branch, not Safari”, and does not work with the commercial Safari (source: playwright.dev, accessed 27 September 2026). Selenium, through the WebDriver model, lists Safari among the supported browsers (source: selenium.dev, accessed 27 September 2026). For the majority of rendering bugs, testing the WebKit engine is enough; for strict validation on the Apple browser, Selenium keeps an advantage.

Can you use Playwright in Java like Selenium?

Yes, Playwright is documented for Java, alongside Node.js, Python and .NET (source: playwright.dev, accessed 27 September 2026). Java teams who want the benefit of auto-waiting and traces without changing language therefore have a migration path.

Why does ADC teach Playwright rather than Selenium?

Because Playwright brings the runner, assertions, isolation, parallelisation and traces together in a single tool (source: playwright.dev, accessed 27 September 2026), which lets a beginner with no prerequisites learn good practices from the first week. Selenium is then covered through guided reading, so that our learners are comfortable with existing suites.

How long does it take to go from Playwright to Selenium?

A few days to read and maintain a suite, a few weeks to write a good-quality one with well-designed explicit waits. The vocabulary (locator, session, wait, page object) is shared; it is the manual handling of synchronisation that demands the most attention.

Become an automation tester with Playwright, no prerequisites

“QA Automation & AI Tester” programme: 399 hours over 12 weeks, 100% online, ISTQB CTFL v4.0 and CT-GenAI v1.1 exams included, ADC Professional Certificate CP-QAI. Session from 15 October 2026 to 15 January 2027, 12 places, registration possible until 22 October. See the funding options.