Playwright is what happens when the team behind Puppeteer rebuilds browser automation from scratch with testing as the primary goal. Developed at Microsoft by many of the same engineers who created Puppeteer at Google, it addresses the pain points that make browser testing frustrating: flaky tests, cross-browser inconsistencies, and complicated setup.

Why Playwright Exists

Puppeteer solved Chrome automation. Selenium solved cross-browser support. Neither solved the fundamental problem: browser tests are often unreliable. Elements load at unpredictable times. Animations interfere with clicks. Network requests race against assertions.

Playwright tackles this with auto-waiting built into every action. When you click a button, Playwright automatically waits for it to be visible, enabled, and stable before clicking. When you assert text content, it retries until the assertion passes or times out. This eliminates most timing-related flakiness without explicit waits scattered through your code.

Core advantages:

Auto-waiting: Every action waits for actionability automatically
Cross-browser: Chromium, Firefox, and WebKit (Safari's engine) from one API
Test isolation: Each test gets a fresh browser context by default
Powerful tooling: Trace viewer, codegen, UI mode for debugging
Multiple languages: JavaScript, TypeScript, Python, Java, .NET

Pro tip: Use npx playwright codegen to record interactions and generate test code. It's the fastest way to understand Playwright's API and bootstrap new tests.

Getting Started

Install Playwright with its test runner:

npm init playwright@latest

This creates a project structure with example tests and configuration. Run the example tests:

npx playwright test

A minimal test file looks like this:

// tests/example.spec.js
const { test, expect } = require('@playwright/test');

test('homepage has correct title', async ({ page }) => {
  await page.goto('https://example.com');
  await expect(page).toHaveTitle(/Example/);
});

That's it. No browser setup, no driver downloads, no explicit waits. Playwright handles all of it.

The Auto-Waiting Difference

Compare explicit waiting in Selenium versus Playwright's approach:

// Selenium style: manual waits everywhere
await driver.get('https://example.com');
await driver.wait(until.elementLocated(By.css('.loaded')), 10000);
await driver.wait(until.elementIsVisible(element), 10000);
await element.click();

// Playwright style: just describe what you want
await page.goto('https://example.com');
await page.click('.loaded');  // Auto-waits for visible, enabled, stable

Playwright waits for these conditions before acting:

Action	Auto-Wait Conditions
`click()`	Visible, stable, enabled, not obscured
`fill()`	Visible, enabled, editable
`check()`	Visible, enabled, unchecked
`selectOption()`	Visible, enabled

If an element doesn't meet conditions within the timeout (30 seconds by default), the test fails with a clear error explaining what went wrong.

Locators: The Modern Way

Playwright encourages "user-facing" locators that find elements the way users perceive them:

// By role (recommended)
await page.getByRole('button', { name: 'Submit' }).click();
await page.getByRole('textbox', { name: 'Email' }).fill('[email protected]');

// By text content
await page.getByText('Welcome back').isVisible();

// By label
await page.getByLabel('Password').fill('secret123');

// By placeholder
await page.getByPlaceholder('Search...').fill('query');

// By test ID (when you control the HTML)
await page.getByTestId('checkout-button').click();

// CSS and XPath still work when needed
await page.locator('.legacy-class').click();
await page.locator('xpath=//div[@id="root"]').isVisible();

Role-based locators are resilient because they match how assistive technologies see your page. If a button looks like a button to screen readers, getByRole('button') will find it regardless of the underlying HTML implementation.

Avoid chaining multiple CSS classes or using auto-generated class names as locators. These break whenever styling changes. Prefer getByRole, getByTestId, or getByLabel for stable tests.

Assertions That Retry

Playwright's assertions automatically retry until they pass:

// Retries until the element contains "Success" or timeout
await expect(page.getByTestId('status')).toHaveText('Success');

// Retries until element is visible
await expect(page.getByRole('dialog')).toBeVisible();

// Retries until URL matches
await expect(page).toHaveURL(/dashboard/);

// Retries until element count matches
await expect(page.getByRole('listitem')).toHaveCount(5);

This retry behavior is what makes Playwright tests reliable. Instead of failing instantly when an assertion doesn't match, it keeps checking until the condition is true or the timeout expires. Perfect for SPAs where content appears after API calls complete.

Cross-Browser Testing

Run tests across all browsers with one command:

npx playwright test --project=chromium --project=firefox --project=webkit

Configure browsers in playwright.config.js:

module.exports = {
  projects: [
    {
      name: 'chromium',
      use: { browserName: 'chromium' },
    },
    {
      name: 'firefox',
      use: { browserName: 'firefox' },
    },
    {
      name: 'webkit',
      use: { browserName: 'webkit' },
    },
    {
      name: 'mobile-chrome',
      use: {
        browserName: 'chromium',
        ...devices['Pixel 5'],
      },
    },
    {
      name: 'mobile-safari',
      use: {
        browserName: 'webkit',
        ...devices['iPhone 13'],
      },
    },
  ],
};

Playwright's WebKit support means you can test Safari rendering without a Mac. It's not identical to real Safari, but it catches most cross-browser issues.

Testing Forms and User Flows

Here's a realistic login test:

const { test, expect } = require('@playwright/test');

test('user can log in and see dashboard', async ({ page }) => {
  await page.goto('https://app.example.com/login');
  
  // Fill the login form
  await page.getByLabel('Email').fill('[email protected]');
  await page.getByLabel('Password').fill('securepassword');
  await page.getByRole('button', { name: 'Sign In' }).click();
  
  // Verify redirect to dashboard
  await expect(page).toHaveURL(/dashboard/);
  await expect(page.getByRole('heading', { name: 'Welcome' })).toBeVisible();
});

test('shows error for invalid credentials', async ({ page }) => {
  await page.goto('https://app.example.com/login');
  
  await page.getByLabel('Email').fill('[email protected]');
  await page.getByLabel('Password').fill('wrongpassword');
  await page.getByRole('button', { name: 'Sign In' }).click();
  
  await expect(page.getByText('Invalid email or password')).toBeVisible();
  await expect(page).toHaveURL(/login/);  // Should stay on login page
});

Network Mocking

Intercept and mock API responses for isolated, fast tests:

test('displays user data from API', async ({ page }) => {
  // Mock the API response
  await page.route('**/api/user', route => {
    route.fulfill({
      status: 200,
      contentType: 'application/json',
      body: JSON.stringify({ id: 1, name: 'Test User', role: 'admin' }),
    });
  });
  
  await page.goto('https://app.example.com/profile');
  
  await expect(page.getByText('Test User')).toBeVisible();
  await expect(page.getByText('admin')).toBeVisible();
});

test('handles API errors gracefully', async ({ page }) => {
  await page.route('**/api/user', route => {
    route.fulfill({ status: 500 });
  });
  
  await page.goto('https://app.example.com/profile');
  
  await expect(page.getByText('Failed to load profile')).toBeVisible();
});

Debugging Failed Tests

Playwright's debugging tools are exceptional:

# Run with headed browser and slow motion
npx playwright test --headed --slowmo=500

# Debug mode: step through test with DevTools
npx playwright test --debug

# UI mode: visual test runner with time-travel
npx playwright test --ui

When tests fail in CI, Playwright can capture traces:

// playwright.config.js
module.exports = {
  use: {
    trace: 'on-first-retry',  // Capture trace on failure
    screenshot: 'only-on-failure',
    video: 'retain-on-failure',
  },
};

View traces with:

npx playwright show-trace trace.zip

The trace viewer shows every action, network request, and DOM snapshot. You can step through the test and see exactly what the page looked like at each moment.

CI Configuration

A GitHub Actions workflow:

name: Playwright Tests
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      
      - name: Install dependencies
        run: npm ci
      
      - name: Install Playwright browsers
        run: npx playwright install --with-deps
      
      - name: Run tests
        run: npx playwright test
      
      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: playwright-report
          path: playwright-report/

When to Choose Playwright

Scenario	Recommendation
New project, any browser	Playwright, the best modern choice
Existing Selenium suite	Migrate gradually or stick with Selenium
Chrome-only, simple needs	Puppeteer is lighter weight
Frontend team, JS-centric	Playwright or Cypress both work well
Non-JS team	Playwright (Python/Java/.NET) or Selenium

Playwright hits a sweet spot: it offers cross-browser support like Selenium does, it offers a developer experience approaching Cypress, and reliability that exceeds both.

Screenshot capture without the infrastructure

Playwright excels at testing, but if your primary need is capturing screenshots rather than running test assertions, managing browser infrastructure adds unnecessary complexity. Each CI run needs browsers installed, and headless Chrome can be resource-intensive.

For screenshot-focused workflows like visual regression baselines, documentation, or link previews, AllScreenshots provides a simpler path:

// Instead of managing Playwright for screenshots
const response = await fetch('https://api.allscreenshots.com/v1/screenshots', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.SCREENSHOT_API_KEY,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    url: 'https://example.com',
    fullPage: true,
    blockAds: true
  })
});

The API handles browser rendering, ad blocking, cookie banner removal, and device emulation. No npx playwright install in your CI pipeline, no browser binaries to cache. For teams already using Playwright for testing, AllScreenshots can handle the screenshot-specific parts of your workflow while Playwright focuses on what it does best: reliable cross-browser tests.

Get started free with 100 screenshots per month.

Conclusion

Playwright removes most of the friction from browser testing. Auto-waiting eliminates timing flakiness. Cross-browser support means one test suite covers Chromium, Firefox, and WebKit. The tooling, such as codegen, trace viewer and UI mode make debugging fast instead of frustrating.

Start with npm init playwright@latest and write tests using role-based locators. Run across browsers in CI from day one. When tests fail, use the trace viewer to understand exactly what happened.

The goal is tests you can trust. Playwright gets closer to that goal than anything else available today.

Find out how easy it is to capture and share pixel-perfect screenshots at scale using Allscreenshots. Sign up for a free account and start integrating your first screenshot API call today.

Alex Chen

Full-stack developer and technical writer who loves browser automation and making complex tools accessible.

Introduction to Playwright for End-to-End Testing

Why Playwright Exists

Getting Started

The Auto-Waiting Difference

Locators: The Modern Way

Assertions That Retry

Cross-Browser Testing

Testing Forms and User Flows

Network Mocking

Debugging Failed Tests

CI Configuration

When to Choose Playwright

Screenshot capture without the infrastructure

Conclusion

Related Posts

Introduction to Puppeteer for Browser Automation

How to download all images from a webpage using Puppeteer

Automating Visual Regression Testing with Screenshot APIs

Start capturing screenshots in minutes

Why Playwright Exists

Getting Started

The Auto-Waiting Difference

Locators: The Modern Way

Assertions That Retry

Cross-Browser Testing

Testing Forms and User Flows

Network Mocking

Debugging Failed Tests

CI Configuration

When to Choose Playwright

Screenshot capture without the infrastructure

Conclusion