There are two ways to plan cross-browser testing, and they lead to very different calendars. The first is the logo approach: make a list of browser names and versions that someone might use, say Chrome, Edge, Firefox, Safari, Samsung Internet, Opera, each in its last three versions, on Windows, macOS, Android and iOS, and run the suite on every combination. The second is the engine approach: group browsers by what actually renders and executes the page, choose representatives, and spend your effort where behaviour genuinely differs. I think the second is better for almost every team, and below I try to be fair to the first.
What really differs between browsers
A browser is, for this purpose, a rendering engine plus a JavaScript engine plus a shell of features around them. Three engine families matter in practice. Blink (with the V8 JavaScript engine) powers Chrome, Edge, Opera, Brave and Samsung Internet. WebKit powers Safari, and for a long time every browser on iPhones and iPads had to use it, whatever its name; rules in some regions, the EU among them, have started to allow alternatives, so check your own users. Gecko powers Firefox.
Consequently, Chrome and Edge on the same platform behave almost identically for page layout and scripts, because they share an engine; the differences are mostly in the surrounding features such as extensions, password managers and built-in translation. Testing your whole suite on both mostly repeats the same observation. Safari, though, has historically been the source of a surprising share of “works everywhere except here” defects: date and time inputs, some CSS features arriving later, stricter handling of cookies and tracking, how media playback and autoplay behave, quirks with viewport height on mobile. Firefox sits in between: fewer surprises than Safari, but real ones, often in form controls and certain layout features.
The case for the logo approach
Fairness first. The logo approach is simple to explain to a client, easy to put in a contract (“supported on the following browsers”) and it does catch the differences in the shell features I just dismissed. If your product relies on browser-specific behaviour, such as payment handlers, WebAuthn passkeys, file upload dialogs, PDF viewers or extensions, those do vary by brand. Regulated or enterprise customers may also run a locked-down corporate browser with policies that change behaviour. In those cases test the actual browser they use.
The problem is the cost curve. Four browsers on three platforms with three versions each is 36 combinations. If the suite takes 40 minutes on one, that is 24 hours of execution per run, before you pay for flaky tests that fail only in one cell. Teams respond by running the full matrix weekly, so defects are found a week late, or by quietly dropping combinations without deciding which ones. Neither is a strategy.
The engine approach, in practice
Start from your own data, not from a global market-share chart. Your analytics will show which browsers and versions your real users have. An Indian consumer app may find that Android Chrome and Samsung Internet dominate, with a notable iOS Safari share; a bank’s internal tool may be almost all desktop Edge. Rank by users, then by revenue or criticality, since a small group using the checkout page can matter more than a large one reading the blog.
Then tier the coverage:
- Tier 1, the primary browser: the full automated suite runs on every change. Usually a Chromium browser, because tooling is strongest there.
- Tier 2, other engines: a smaller set of critical journeys (sign-up, login, search, checkout, payment) runs on WebKit and Gecko in the pipeline. Playwright, for example, ships Chromium, Firefox and WebKit builds, which makes this cheap. Treat its WebKit build as a close proxy for Safari, not as proof of Safari, especially on iOS.
- Tier 3, real devices and edge cases: a periodic pass on real iPhones and mid-range Android phones, using a device cloud or an in-house shelf, focusing on layout, touch, keyboard behaviour, camera and file upload.
- Everything else: named, by decision, as best-effort. Older browsers fall into this group.
That gives coverage of every engine on every change, at the price of a small subset of tests, and it concentrates the expensive real-device effort where fragmentation actually exists.
Write the support policy down
Much of the confusion disappears once the product team publishes a support statement: “latest two major versions of Chrome, Edge, Firefox and Safari; Samsung Internet latest; iOS and Android versions released in the last N years.” Then a defect on an unsupported browser can be triaged on its merits instead of argued about. Review the statement once or twice a year, using fresh usage data.
Reduce what has to be tested in the first place
The cheapest cross-browser defect is one that never happens. Developers can use feature support data, such as the MDN compatibility tables or caniuse, before choosing a new CSS or JavaScript feature, and linting or build tools can flag unsupported ones. A progressive-enhancement habit, where the basic function works everywhere and the fancy parts improve it, shrinks the testing surface. Also separate logic from layout in your tests: functional behaviour is mostly engine-independent and is well covered on the primary browser, whereas layout and visual rendering are what actually differ, so visual comparison on the other engines is where the investment belongs. Visual diffs need stable baselines per browser, since font rendering differs by platform.
Where I land: choose engines, back the choice with your own usage numbers, run the full suite once and a critical subset on the others, keep a small real-device habit, and write the policy down. If a customer’s contract names a specific browser, add that browser. Otherwise, a logo on the list is not a reason to run 500 tests that cannot tell you anything the first run did not.
Figures and names in the examples are illustrative.
Leave a Reply