A cross-browser matrix teams actually use
Browser coverage spreadsheets die in folders. Here is how I choose which browsers to test and keep a small matrix alive from sprint to sprint.
Cross-browser testing goes wrong when it is a one-time audit. Someone builds a spreadsheet with a dozen browsers down the side, fills it in before a big launch and files it. After that the team tests in Chrome because that is what the developers use, Safari problems surface in UAT, and QA gets blamed for finding them late.
The fix is a matrix small enough to maintain and honest enough to trust. My web work has run from brand sites for banking and industrial companies to platforms with a public site, a back office and mobile apps side by side, and the matrix that survives is always smaller than the one people first ask for.
How to choose which browsers to test
I pick from analytics and user reality, not from a vendor checklist. Analytics show which browsers and devices the sessions come from. User reality fills in what analytics miss: the back-office team on managed Windows laptops where IT sets the browser, the field staff on whatever phone they were issued, the director who approves things from an iPad.
It helps to think in engines before brands. Chrome and Edge are both built on Chromium, so on the same operating system they behave alike for most journeys. Safari runs on WebKit and Firefox on Gecko. Browsers on iPhone have traditionally been built on WebKit whatever the icon says, so Chrome on an iPhone behaves more like Safari than like Chrome on a laptop.
For most products that gives a short list: current Chrome, Safari and Firefox on desktop, Safari on iPhone, Chrome on Android, and one legacy case if the business still has that cohort. Edge earns its own row when users are on corporate machines, where managed settings for pop-ups and downloads can differ from a developer’s Chrome even though the engine does not. Mobile gets its own rows, not a footnote.
How to tier browsers so the matrix stays small
Not every row deserves the same effort. I sort them into three tiers and agree the tiers with Product.
| Tier | What belongs in it | What it gets each release |
|---|---|---|
| 1 | The browsers and devices most users and the decision-makers are on | Critical journeys by hand, every release |
| 2 | Smaller but real cohorts, and any engine not covered in Tier 1 | Critical journeys when the release touches them, plus a rotating check |
| 3 | Everything else | Not tested. Reported problems are triaged like any other defect |
Tier 3 is a deliberate statement. Writing “we do not test this” where Product can see it turns a gap into an agreed position.
What each cell in the matrix has to prove
Rows are surfaces. Columns are the critical journeys: signing in, the thing that earns revenue, the thing that needs an approval. Each cell answers one question: did we exercise this journey on this surface in this release? Not “did BrowserStack run” but “did a human confirm checkout on Safari with real behaviour”: a real account, the autofill users have switched on, the redirect out to the payment provider and back.
I use BrowserStack and physical devices for different jobs. A cloud browser is fine for confirming that a desktop journey completes on an engine I do not have locally. A phone in the hand is where I find the keyboard covering the button and the camera upload that fails, which is the argument of Mobile QA beyond “run it on BrowserStack”. The cell records which it was.
A cell has three possible states: checked on this build, not checked with a reason, or deferred with a named risk and the person who accepted it. A tick carried over from the previous release is not one of them.
- Release 7.3, build rc2. Journeys: sign in / book and pay / approve a request.
- Chrome on Windows, Safari on macOS (Tier 1): all three checked by hand on rc2.
- Safari, iPhone, physical device (Tier 1): sign in and pay checked on rc2. Approve: not applicable, the back office is desktop only.
- Chrome, Android, physical device (Tier 1): all three checked on rc1. Pay re-checked on rc2 after the payment fix.
- Firefox, Windows (Tier 2): sign in and pay checked on BrowserStack. Approve deferred. Risk: approvers on Firefox meet an unverified screen. Accepted by: Product owner.
- Edge, managed Windows (Tier 2): not checked. Nothing in this build touches downloads or pop-ups.
- Everything else: Tier 3, not tested.
How to keep a browser matrix up to date
The matrix lives beside the readiness note, and the note refers to it. That one habit does most of the work, because the release cannot be described without filling it in. When a cell is deferred, the note names the business risk and who accepts it, which keeps Product in the conversation instead of discovering the gap in a stakeholder demo. How that acceptance should happen is the subject of Go/no-go readiness without greenwashing.
A few rules stop it growing back into the spreadsheet nobody opens.
- It fits on one page. If it scrolls sideways, it has too many columns.
- Adding a row means stating what it costs every release and, usually, which row drops a tier.
- Tiers are reviewed against analytics each quarter, on a date in the calendar.
- Developers get the Tier 1 list. A Safari check before merge is cheaper than one in release week.
- The change decides the depth, as it does for regression. A release that touches forms, uploads or sign-in gets the full matrix. A copy change does not.
Objections to a small browser matrix
The common one is that Safari, or Firefox, or mobile is a small share of traffic. Ask who is in that share. If the people who sign the contract, approve the budget or run the UAT session are on a Mac or an iPhone, a small share carries a lot of weight, and they will find the problem in the least convenient meeting.
The second is that the automated suite already runs on several browsers. That is useful for catching a journey that fails outright. It does not tell you the date picker was usable or that autofill put the postcode in the right field. A run is evidence that scripts completed. The matrix asks whether a person could.
The third comes from testers: a small matrix feels like negligence. I think the opposite is true. A large matrix nobody maintains gives no cover at all. A small one that is current shows everyone exactly where the cover stops.
A useful matrix is boring, repeated and visible. After a few releases the Safari surprise in UAT stops happening, less because more was tested than because the gaps were agreed in daylight. Release week loses one of its more reliable sources of fireworks.
Questions I get asked
Which browsers should you include in cross-browser testing?
Start from your own analytics and from what you know about your users’ machines, not from a generic list. For most products that means current Chrome, Safari and Firefox on desktop, Safari on iPhone and Chrome on Android, plus Edge where users are on corporate laptops, and one legacy browser only if a real cohort still depends on it.
How many browsers is enough for cross-browser testing?
Enough to cover each engine your users are on and each device class they use, and few enough that the critical journeys can be checked by hand on the top tier every release. If the matrix cannot be completed in the time a release allows, it is too big, and an unfinished matrix protects nobody.
Is BrowserStack enough for cross-browser testing?
It covers a lot, mainly confirming that a journey completes on a browser or operating system you do not have to hand. It is weaker on behaviour that depends on a real device and a real user profile, such as saved autofill data, the on-screen keyboard and camera uploads. I use it alongside a small set of physical devices and record in the matrix which one each check ran on.
Filed under Release readiness and regression. Terms: Cross-browser testing.
