The team’s E2E suite takes 32 minutes on Cypress. Every PR sits in CI for half an hour. Somebody points out that Playwright runs the same kind of suite in 8 minutes. The team weighs the migration cost against the saved CI time and decides to migrate. Six weeks later, the suite is faster, more reliable, and works in three browsers instead of one.

Cypress was the right tool in 2018. By 2024, Playwright has the better feature set, the faster runtime, and the better cross-browser story. That doesn’t automatically mean every team should migrate. Cypress is still fine for projects with a small, stable suite and no interest in cross-browser testing. But the case for new projects starting on Playwright is overwhelming.

This post is the honest comparison: where each one wins, where the gap is, what migration costs, and the patterns that work in either.

The honest tradeoffs

Concern	Cypress	Playwright
Cross-browser	Chrome, Firefox, Edge (Safari only via “experimental” WebKit)	Chrome, Firefox, WebKit (real Safari engine), first-class
Parallelism	Paid feature (Cypress Cloud)	Free, built-in, zero config
Test runtime (typical suite)	Slower (single-tab architecture)	2-4x faster (multi-context, true parallel)
API stability	Mature, stable	Mature, stable since ~2022
Mobile emulation	Limited	Full device emulation
Auto-waiting	Yes	Yes (more comprehensive)
Debugging UX	Excellent (interactive UI)	Excellent (Trace Viewer, Inspector)
Network mocking	cy.intercept() (good)	page.route() (good, with more flexibility)
Multiple tabs / windows	Hard / partial support	First-class
CI cost	Higher (parallelism is paid)	Lower (parallelism is free)

For most measurable axes, Playwright leads or ties. The historical Cypress wins (DX, time-travel debugging) have been largely matched by Playwright’s Trace Viewer.

What each looks like in code

Cypress:

describe('login', () => {
  it('logs in with valid creds', () => {
    cy.visit('/login');
    cy.get('[data-test="email"]').type('test@example.com');
    cy.get('[data-test="password"]').type('password123');
    cy.get('[data-test="submit"]').click();
    cy.url().should('include', '/dashboard');
    cy.contains('Welcome');
  });
});

Playwright:

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

test('logs in with valid creds', async ({ page }) => {
  await page.goto('/login');
  await page.getByTestId('email').fill('test@example.com');
  await page.getByTestId('password').fill('password123');
  await page.getByTestId('submit').click();
  await expect(page).toHaveURL(/dashboard/);
  await expect(page.getByText('Welcome')).toBeVisible();
});

The shapes are similar. Playwright is async/await; Cypress uses a chained command queue. For most teams, async/await is the more familiar pattern.

The runtime difference, explained

Cypress runs your tests inside the browser as part of the page. One tab, one process, sequential within a spec file. Parallelism (multiple spec files at once) requires Cypress Cloud (a paid service) or a self-hosted runner.

Playwright runs tests outside the browser via the DevTools Protocol. Multiple browser contexts can run in parallel within one process. Multiple workers run in parallel out of the box. A 100-spec suite runs across N workers, where N is your CI machine’s core count.

For a 30-test suite on a 4-core CI runner: Cypress runs in ~10 minutes (sequential), Playwright in ~3 minutes (4-way parallel). The math is the math.

Trace Viewer: the Cypress-killer feature

Playwright’s Trace Viewer records every action, every network request, every DOM change, and every screenshot during a test. When a test fails in CI, you download the trace, open it locally, and replay the entire test:

npx playwright show-trace trace.zip

You see exactly what the page looked like at each step, what selectors matched, what network calls happened. It is the same level of debugging that Cypress’ interactive runner gave you, but on a CI failure trace, not just locally.

This single feature makes Playwright debugging much faster than the “stare at the failed assertion and guess” approach.

Cross-browser is now real

Cypress’ Safari/WebKit support is genuinely experimental, and many teams find tests pass on Safari with caveats and surprises. Playwright runs against real WebKit (the engine Safari uses), Chromium, and Firefox out of the box:

// playwright.config.ts
projects: [
  { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
  { name: 'firefox',  use: { ...devices['Desktop Firefox'] } },
  { name: 'webkit',   use: { ...devices['Desktop Safari'] } },
],

Same test runs against all three. Real bug-catching for sites that need to work on Safari (most consumer-facing sites).

Mobile emulation

Playwright supports full device emulation:

import { devices } from '@playwright/test';

projects: [
  { name: 'mobile-chrome', use: devices['Pixel 5'] },
  { name: 'mobile-safari', use: devices['iPhone 13'] },
],

User agent, viewport, touch events, geolocation: all emulated correctly. For sites with significant mobile usage, this is the right way to ensure mobile-specific behavior is tested.

Where Cypress is still good

Two scenarios where Cypress is still fine:

Small, stable test suites. If your E2E suite is 30 tests and runs in 5 minutes, the absolute time savings of Playwright are minor. Migration costs more than the saved time.

Teams already invested. A team with 200 Cypress tests, custom commands, and a polished CI pipeline shouldn’t migrate just because a new tool exists. The migration is real work; only do it if there’s a clear pain.

For new projects starting today, Playwright is the default. For existing Cypress projects, evaluate cost-benefit honestly.

Migration patterns

If you decide to migrate from Cypress:

1. Start with the slowest specs. The biggest CI-time wins come from the longest-running tests. Translate them first; you get measurable benefit immediately.

2. Run side-by-side initially. New tests in Playwright; old ones still in Cypress. CI runs both. As Cypress tests get translated, they’re deleted. Avoids a “freeze” period.

3. Translate utilities last. Custom Cypress commands (cy.login(), cy.seedDatabase()) are usually 80% of the migration work. Translate them after you’ve translated enough tests to know what shape they need.

4. Fix flakes during migration. Cypress tests often have implicit timing assumptions. Playwright’s stricter waiting catches these. Fix them properly rather than papering over.

A typical migration for a 100-test suite takes 4-6 weeks of part-time work for one engineer.

Patterns that work in both

A few good practices regardless of tool:

Use data-test attributes for selectors. data-test="submit" is stable across CSS / className changes.

<button data-test="submit">Send</button>

// Playwright
await page.getByTestId('submit').click();
// Cypress
cy.get('[data-test="submit"]').click();

Avoid hardcoded waits. await page.waitForTimeout(2000) is a code smell. Both tools have explicit waiting (expect(...).toBeVisible(), cy.contains(...)), so use it.

Reset state between tests. Each test should be independent. API calls to seed/clean data, not “test 2 depends on test 1.”

Page Object Model (carefully). A LoginPage class with methods (fillEmail, fillPassword, submit) makes tests readable. Don’t over-engineer; sometimes inline calls are cleaner.

CI integration

Both run on standard CI. Some considerations:

• Cache the browser binaries. Playwright/Cypress download browsers; cache them across CI runs.
• Use sharding. Playwright’s --shard 1/4, Cypress’ parallel: true with Cloud. Distributes specs across workers.
• Headed runs in CI for video. Both can capture video on failure. Useful for debugging but slower; enable only on failure.
• Retry flaky tests. Both support test-level retries. Use sparingly; flakiness is usually a real bug.

The takeaway

In 2024, Playwright is the better tool for new E2E test suites: faster, free parallelism, real cross-browser, better debugging via Trace Viewer. Cypress is still fine for established suites where the migration cost outweighs the speed-up. Make the call based on actual numbers: your suite’s runtime, your team’s velocity, your need for cross-browser.

Don’t migrate as fashion. Migrate because you measured the cost and the benefit.

---

A note from Yojji

The kind of testing-infrastructure judgment that turns a slow flaky CI suite into a fast reliable one (picking the right tool, setting up parallelism, fixing flakes properly) is the kind of long-haul engineering discipline Yojji’s QA and dev teams build into the products they ship for clients.

Yojji is an international custom software development company founded in 2016, with teams across Europe, the US, and the UK. They specialize in the JavaScript ecosystem (React, Node.js, TypeScript), cloud platforms (AWS, Azure, GCP), and full-cycle product engineering, including the testing infrastructure that decides whether your CI is a bottleneck or an asset.