Web app testing

What Is Cross-Browser Testing? A Complete Guide

Key takeaways

  • Modern browsers rarely disagree, so most cross-browser bugs now come from legacy code and older browsers.

    Chrome, Edge, Firefox and Safari update themselves, and each passed 98 to 99% of the shared tests in the browser makers' 2025 Interop project.

  • Focus cross-browser testing where legacy systems are involved.

    Apps and front-end code built for Internet Explorer or older browsers, old embedded components and customers who still run older versions are where a flow still breaks in one browser.

  • Choose browsers from your own analytics instead of testing every combination.

    Grids of hundreds of browser, version and operating system combinations are a holdover from tools built when browsers disagreed.

  • Write the tests in Playwright, so any flow can run in Chromium, Firefox and WebKit.

    It drives all three engines from one API for free, while Selenium needs a browser grid you maintain and Cypress makes Safari hard to test.

  • Run the full suite on every pull request, in parallel, in each browser on your list.

    Each browser adds a full set of test runs, and running them all at once keeps the suite about as fast as its slowest test.

Cross-browser testing used to mean checking every page in Internet Explorer, Firefox, Safari and Chrome, because each one drew the same page differently.

Cross-browser testing checks that a web app works and looks right in every browser its users use, such as Chrome, Safari, Firefox and Edge. Modern browsers now follow the same web standards closely, so for most apps it matters mainly where legacy systems are involved: code written for older browsers, old embedded components and customers who still run older browsers.

What is cross-browser testing?

Cross-browser testing is the practice of running a web app's user flows in several browsers, browser versions, operating systems and screen sizes, and checking that each one works and displays correctly. It's also called browser compatibility testing or multi-browser testing, and it's one part of web app testing.

Each browser is built on a rendering engine, the part that turns HTML, CSS and JavaScript into the page a user sees. Three engines run almost every browser in use today:

  • Chromium runs Chrome, Microsoft Edge, Opera, Brave, Samsung Internet and most other browsers.
  • WebKit runs Safari on Mac, iPhone and iPad. Apple requires browsers on iPhone to use WebKit in most countries, so Chrome and Firefox for iPhone run on WebKit too.
  • Gecko runs Firefox on desktop and Android.

All three update themselves and implement the same web standards, so a modern app usually behaves the same in each.

Most cross-browser testing is end-to-end testing, since each test drives the app through its interface the way a user does, once in each browser. Native iOS and Android apps don't run in a browser, so they're covered by mobile app testing instead.

Why is cross-browser testing important?

Cross-browser testing mattered most when browsers disagreed. Through the 2000s and 2010s, Internet Explorer, Firefox, Safari and Chrome each read web code their own way, and a page could work in one and break in the next, so teams checked every page in every browser.

That gap has mostly closed. Today's browsers update themselves, so nearly every user runs a recent version, and Microsoft retired Internet Explorer in June 2022. Apple, Google, Microsoft and Mozilla also fix their differences together in a yearly project called Interop. By the end of 2025, 97% of the project's tests passed in every major browser at once, and Chrome, Edge, Firefox and Safari each passed 98 to 99% (Microsoft Edge blog).

Cross-browser testing still matters where legacy systems are involved. An app built for Internet Explorer or an older browser, front-end code full of browser-specific workarounds, old embedded components and customers who still run older browser versions are where a user flow can still work in one browser and break in another.

Common cross-browser compatibility issues

Most cross-browser bugs now come from legacy systems rather than from today's browser engines. These are the usual sources:

  • Code written for Internet Explorer or older browsers. Workarounds for old browsers, such as browser sniffing, vendor-prefixed CSS and polyfills, can misfire in a modern browser that doesn't need them.
  • Customers on older browsers. Some enterprise and public-sector customers lock their browser versions or run older web apps in Microsoft Edge's Internet Explorer mode, so a feature built on a newer browser feature needs a fallback.
  • Old embedded components. Plugins, third-party widgets and internal tools built for one browser can fail in another, even when the app around them works.
  • Privacy rules. Safari blocks third-party cookies by default and Firefox keeps each site's cookies separate, so a sign-in or payment form loaded from another domain can work in Chrome and fail in both. These are deliberate policies, not engine bugs, and they're the main difference left among current browsers.

Which browsers should you test?

Test the browsers your users actually use, chosen from your product analytics, instead of a grid of every combination. For a modern app on current browsers that list is short, plus any older browser your customers are required to use.

  • Start from your analytics. List browsers, versions, operating systems and screen sizes by their share of real sessions, after filtering out bot traffic, which can inflate some browsers. Then weigh each by what's at stake, such as the share of sign-ups or revenue that comes through it.
  • Add what legacy systems require. If customers run older browser versions or Edge's Internet Explorer mode, those go on the list, with the flows those customers use.
  • Set a version policy. Browsers update themselves, so a common policy is the latest two versions of each. Older versions go on the list only where customers require them, as some banks, government agencies, schools and hospitals still do. Internet Explorer itself can come off the list, since Microsoft retired it in June 2022.
  • Revisit the list as your traffic changes. A new market, a new customer or a new device can change which browsers matter.

Keep the list short enough that the full suite can run in every browser on it, on every pull request, instead of trying to cover every combination of browser, version, operating system and device.

When automated cross-browser testing is necessary

Automated cross-browser testing is necessary when legacy systems make browser differences likely. For a modern app on current browsers, a suite that runs every user flow in one browser catches almost all of its bugs, and other browsers add little. It matters in these cases:

  • The front-end code is old. Code written before today's standards, or full of browser-specific workarounds, breaks more often when browsers update. When a team modernizes it, a cross-browser suite shows that every flow still works in every browser.
  • Customers require older browsers. Some enterprise and public-sector customers lock their browser versions, so a feature built on a newer browser feature needs a fallback and a test that proves it works.
  • The app embeds legacy components. Old plugins, third-party widgets and internal tools that were built for one browser need checking in the others.
  • A flow crosses domains or stores data. Signing in through another provider, embedded payments and anything that depends on cookies behave differently under Safari's and Firefox's privacy rules.

When to automate cross-browser testing

Automate a flow's test as soon as the flow is built, and run the full suite in each browser on your list on every pull request. A person checks each new feature first, judging layout and feel that a script can't. Then the team adds an automated test, so the flow is checked in every browser on every change after that, as part of your regression testing.

Every browser adds a full set of test runs, so a suite of 300 tests in two browsers is 600 runs. Run one after another, the suite gets slower with every browser added. With parallel testing, every test in every browser starts at once, so the suite takes about as long as its slowest test.

QA Wolf

Every test at once, each in its own container

10 parallel nodes

10 tests at a time, 20 on each node

200 tests that take 5 to 10 minutes each, run two ways. QA Wolf runs every test at once, each in its own container, so the suite is done in 10 minutes, the time of its longest test. On 10 parallel nodes, each node runs 20 of the tests one after another, so the suite takes about 2 and a half hours.

200 tests that take 5 to 10 minutes each. Run all at once, the suite is done when the longest test is, at 10 minutes. On 10 parallel nodes, each node runs 20 of them one after another, and the suite takes about 2½ hours. After the first 10 minutes, the nodes' clock fast-forwards. Each test's time is illustrative.

Add screenshot comparisons for the pages where layout matters, since a page can pass every functional check and still look broken in one browser. Visual regression testing compares each screenshot with an approved baseline, and each browser needs a baseline of its own, because each engine draws text and spacing a little differently.

How do you automate cross-browser testing?

To automate cross-browser testing, write each user flow once as an end-to-end test in a framework that drives every browser engine, configure it to run in each target browser, and run the full suite in parallel in CI on every pull request.

Write the tests in Playwright

Playwright is the best framework for cross-browser testing. One API drives Chromium, Firefox and WebKit, the engines behind Chrome and Edge, Firefox and Safari, and it can also run the branded Chrome and Edge builds. It emulates phones such as an iPhone or a Pixel, with their screen size, touch input and user agent. It waits for elements on its own, runs tests in parallel for free and records a trace of every run, so a failure in one browser can be replayed step by step. Playwright's WebKit is built from the same open-source engine as Safari, so it shows how Safari's engine handles your app, though it isn't the Safari app itself.

Selenium and Cypress are the other common choices. QA Wolf doesn't recommend either for a new suite:

  • Selenium drives Chrome, Firefox, Edge and Safari through each browser's own driver and supports many languages. But running tests in parallel means setting up and maintaining your own grid of browsers, and waiting, retries and reporting are left to your team.
  • Cypress runs tests inside the browser, which makes Safari, a second tab and a second user hard to test. QA Wolf sees nothing Cypress does that Playwright can't do better, so teams on Cypress should write new tests in Playwright and start migrating, critical flows first.

On QA Wolf's cross-browser testing platform, AI agents write and maintain the tests in open-source Playwright, standard code you own and can take anywhere.

Run each test in every target browser

In Playwright, each browser is a project in the config file, and every test runs once in each project. Keep only the browsers your analytics and legacy systems call for. This config shows all three engines, and WebKit on an emulated iPhone 15:

// playwright.config.ts
import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  fullyParallel: true,
  projects: [
    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
    { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
    { name: 'webkit', use: { ...devices['Desktop Safari'] } },
    { name: 'Mobile Safari', use: { ...devices['iPhone 15'] } },
  ],
});

The test is written once, in Arrange-Act-Assert steps, which set up the state, take the user's action and check the result. It runs against Playwright's public TodoMVC demo app, adds two to-dos, completes one and checks that only the other is listed as active:

// tests/todo.spec.ts
import { test, expect } from '@playwright/test';

test('a user can complete a to-do and see only the active ones', async ({ page }) => {
  // Arrange: open the app and add two to-dos
  await page.goto('https://demo.playwright.dev/todomvc/');
  const newTodo = page.getByPlaceholder('What needs to be done?');
  for (const title of ['Book the venue', 'Send the invites']) {
    await newTodo.fill(title);
    await newTodo.press('Enter');
  }

  // Act: complete the first to-do, then filter to the active ones
  await page.getByTestId('todo-item').filter({ hasText: 'Book the venue' }).getByRole('checkbox').check();
  await page.getByRole('link', { name: 'Active' }).click();

  // Assert: only the open to-do is listed, and the counter agrees
  // (soft checks, since nothing after them depends on them)
  await expect.soft(page.getByTestId('todo-item')).toHaveText(['Send the invites']);
  await expect.soft(page.getByTestId('todo-count')).toHaveText('1 item left');
});

Run npx playwright test and the test runs four times, once in each browser, in parallel. Both checks are soft assertions, so a failed one is recorded and the test keeps going, which lets one run report every failed check. A check that a later step relies on, such as the page loading, stays a hard assertion that stops the test.

Run the full suite in CI on every pull request

Add a CI job that deploys each pull request to a preview environment, a temporary copy of the app built from that pull request's code. The job runs the full suite in every browser against it and blocks the merge if a test fails. Running tests on every change like this is part of continuous testing.

The browsers can run on CI machines or containers your team manages, or in the cloud on cross-browser testing tools such as BrowserStack, Sauce Labs or LambdaTest, which also rent real Macs and phones. Either way, your team still writes the tests, investigates their failures and keeps them up to date.

What makes cross-browser testing hard?

Cross-browser testing is hard because every browser multiplies the suite, and each one brings its own timing and rendering. Those difficulties then cost the development team time and trust.

What makes cross-browser tests hard to run and keep reliable

  • Every browser multiplies the runs. Each browser added runs the whole suite again, which needs more machines, or more time if the runs wait in line.
  • Each browser adds its own flakes. A flaky test passes on one run and fails on the next with no change to the code. Engines load pages and fire events at slightly different speeds, so a test that waits a fixed time can pass in Chrome and fail in WebKit. Waiting for the app's state instead of a timer prevents most of these.
  • Each failure needs sorting. A failure in one browser could be a real browser-specific bug, a test that only works in one engine, or a flake, and telling them apart takes a look at the same test's run in every browser.
  • Product changes break tests in every browser. A redesign breaks the same test in every browser at once, and the fix has to pass in all of them.
  • Safari only runs on Apple hardware. Testing the Safari app itself, on a Mac or an iPhone, means Apple machines in your own lab or rented from a cloud grid.

How those difficulties affect development teams

  • Slow cross-browser runs get moved off pull requests. Teams run only Chrome on each pull request and leave Safari and Firefox for a nightly run, so a browser-specific bug is found after it merges, mixed in with everyone else's changes.
  • Flakes in one browser teach teams to ignore it. Once the WebKit job fails often for no reason, developers rerun it or skip it, and real Safari bugs get through with the false alarms.
  • Investigation and maintenance outgrow test writing. Every failure in every browser needs a verdict and every broken test needs a fix, so the ongoing work grows with each browser added.

How does QA Wolf do cross-browser testing?

QA Wolf's AI agents write your cross-browser tests in Playwright, run them in Chrome, Firefox and Safari's WebKit engine in parallel on every pull request, investigate every failure and keep the tests up to date. Sign up and ask the agent to map your app and build tests for your most important flows in the browsers your users use. When an agent needs a question answered, such as whether a change in one browser was intended, it asks you. From QA Wolf's docs and engineering posts:

  • The agent maps your app's user flows. It explores your app, maps its workflows by feature and writes an Arrange-Act-Assert outline for each test, and when you ship new features, you can ask it to explore what changed.
  • It writes tests as code you own. Describe a flow in plain language, and the agent writes it in Playwright, standard code your team can read, version and run anywhere.
  • Each test runs in its own clean browser. Every test and every retry gets a fresh container with a new, headed browser, so nothing carries over between runs.
  • Tests run in Chrome, Firefox and Safari. Each web test targets the browser it runs in, and each browser is also available with a GPU.
  • Every test runs at once. The suite finishes in about the time of its longest test, however many browsers it runs in. PR testing runs it against each pull request's preview deploy and posts the result on the pull request.
  • Every failure gets investigated. QA Wolf's AI starts investigating while the rest of the suite is still running, sorting each failure into a product bug, an out-of-date test or a flake. Real bugs are reported to you with a recording, logs and steps.
  • One run reports every failed check. The agent writes soft assertions for the checks nothing later in a test depends on, and diagnoses each failure on its own, so failures with different causes become separate bug reports.
  • The agents maintain the tests. When your product changes, they update the tests it breaks, with unlimited repairs, so the suite keeps passing in every browser.

On 1,567 evals across web, iOS and Android apps, QA Wolf passed 93%, against 78% for Claude Code and 74% for Codex.

In QA Wolf's data on 127 recurring suites, the median time from every test having run to every failure having a conclusion fell from 2.3 hours with human investigation to 21 minutes with AI investigation (data through Oct 15, 2026).

On QA Wolf's full service, the same agents do the work and send their questions to QA Wolf's engineers instead of your team.

Start now and ask the agent to map your app and build cross-browser tests for your most important flows, or talk to sales.

Frequently asked questions

  • What is cross-browser testing?

    Cross-browser testing checks that a web app works and looks right in every browser its users use, such as Chrome, Safari, Firefox and Edge, on desktop and mobile. Modern browsers follow the same web standards closely, so cross-browser testing matters most for legacy code, old embedded components and customers who still run older browsers.

  • How do you do cross-browser testing?

    Pick the browsers to support from your analytics, plus any older browsers your customers require. A person checks each new feature in those browsers first, then the team writes an automated end-to-end test for each user flow and runs it in every target browser on every pull request. Playwright runs the same test in Chromium, Firefox and WebKit from one config file.

  • How do you automate cross-browser testing?

    Write each user flow as an end-to-end test in a framework that drives every browser engine, such as Playwright, which runs the same test in Chromium, Firefox and WebKit. Then run the full suite in each browser on your list, in parallel, in CI on every pull request. QA Wolf's AI agents write, run, investigate and maintain those tests for you.

  • What is browser compatibility testing?

    Browser compatibility testing checks that a website or web app works and displays correctly in every browser and browser version it supports. It's another name for cross-browser testing, and it covers layout, forms, scripts and features such as cookies and device access in each browser.

  • What's the difference between compatibility testing and cross-browser testing?

    Compatibility testing checks that software works in every environment it supports, including operating systems, devices, screen sizes, networks and other software. Cross-browser testing is the part of compatibility testing that covers web browsers and their versions.

  • What is multi-browser testing?

    Multi-browser testing is another name for cross-browser testing. It runs the same tests in several browsers, such as Chrome, Safari and Firefox, to check that an app works the same way in each.

  • Is there a free cross-browser testing tool?

    Yes. Playwright is free and open source, and it runs the same tests in Chromium, Firefox and WebKit, Safari's engine, on your own computer or in CI. The costs come from the machines that run the browsers in parallel, real Macs and phones if you need them, and the time to write and maintain the tests.

  • What is headless browser testing?

    Headless browser testing runs tests in a browser with no visible window, which makes runs lighter on CI machines, and Playwright runs headless by default. A headed browser draws the page the way a user sees it, which is why QA Wolf runs tests in headed browsers and records every run.

  • What are QA automation services for cross-browser testing?

    QA automation services for cross-browser testing build, run and maintain automated tests that check a web app's user flows in every browser its customers use. QA Wolf's AI agents write the tests in Playwright, run them in Chrome, Firefox and Safari's WebKit engine in parallel on every pull request, investigate every failure and keep the tests up to date. On QA Wolf's full service, the agents send their questions to QA Wolf's engineers instead of your team.

More from the blog

All posts