Tracking & QA validation
Tracking and QA validation, so a test result is worth acting on
We check that your experiments measure what you believe they measure: every event firing once, on both arms, on the devices your customers really use and in every consent state, with the numbers reconciled against the orders your store actually took.
This is the layer underneath a readout. Get it wrong and a confident result is just a confident mistake, because no amount of statistics downstream can recover a number that was never collected properly.
- Checked on the browsers and handsets your traffic runs
- Verified before a visitor ever sees the test
The problem
What breaks between the variation and the readout
A test can be built correctly and still return a number nobody should act on. The fault is rarely in the statistics. It is in the layer feeding them, and it fails quietly.
The same event, counted twice
A listener rebound on every render, a tag firing from both the container and the theme, or a purchase replayed on refresh. The count inflates on whichever arm renders more.
An event that only survives on the control
The variation replaces the node a listener was bound to, so the click stops being measured. That arm looks worse because it reports less, with nothing visibly wrong.
Traffic that was never a customer
Known crawlers are already dropped for you. The risk is traffic that pretends: scrapers with real browser strings, uptime and screenshot services, your own team walking a link.
Identity lost at a boundary
A shopper crossing to a payment host never added to cross-domain measurement becomes a second person on a second session, source gone. Consent boundaries do the same.
Instrumentation is not paperwork you file after the build. It is what your decision is made of, so we treat it as the deliverable rather than the setup.
Why your analytics and your order ledger disagree
Nearly every store has a gap between the orders in its admin and the purchases in its analytics. A small, stable gap is normal. A gap that moves, or one nobody has measured, is why two people can hold opposite views about a test.
The first job is to size it and name its parts. Blockers and tracking prevention remove sessions before a tag runs. Where analytics storage is denied, Google tags fall back to a restricted mode, with URL passthrough documented as the mitigation for continuity without cookies. Refunds, cancellations and test orders sit in the admin and never appear in the funnel.
| What you see | Usual cause | How it is confirmed |
|---|---|---|
| Analytics under-reports orders by a steady margin | Blocked, prevented or consent-denied sessions never reach the tag | The order export against the purchase count, over two windows |
| Analytics over-reports revenue | The purchase event replays on refresh or back-navigation | Transaction identifiers deduplicated, so repeats are counted |
| One arm reports fewer add-to-carts | A listener bound to a node the variation replaces | The variation loaded on real hardware, event stream live |
| Sessions double on the way into checkout | A checkout or payment host missing from cross-domain measurement | A purchase walked end to end, identifiers read at each hop |
Two of those share one cause. Google requires each domain listed for cross-domain measurement, tagged from one web data stream. Without it, one shopper crossing a boundary becomes two people on two sessions, and on a split test that lands unevenly.
None of this ends at a perfect match. It ends at a known, stable ratio, so when a test moves a number you can say whether that was customers or plumbing. Our guide to building a GA4 ecommerce funnel covers the same ground from the analyst’s side.
The pre-launch QA matrix, and the axis most teams skip
A variation nobody has opened on the devices your customers use has not been QA’d, it has been looked at. Four axes cross here; the third is the one nobody inherited a runbook for.
- Browsers at the versions your own analytics says your traffic runs, not the ones on the machine it was written on.
- Customer states: logged in, returning with a populated cart, a discount applied, a shipping address that changes the total.
- Consent states: granted, denied, and the reload when somebody changes their mind. Google documents that a late update leaves sessions missing their session_start event.
- Arrival paths: a paid click carrying parameters, an email click, an in-app browser, a direct arrival, where assignment and attribution disagree.
Every cell is somewhere a variation renders perfectly and measures wrongly. Our article on pre-launch checks worth running is the reasoning behind this pass; the QA checklist template is the sheet itself, free and ungated. Run the matrix in-house with both, and keep us for the cells you cannot close.
What we build
What a validation pass actually covers
Instrumentation review
- Each goal, click and revenue metric traced from the element firing it to the property receiving it
- Double-bound and rebound listeners found in the live event stream, not by reading the container
- Data layer contents and push order checked against what the tool assumes exists
The matrix pass
- Browsers and handsets at the versions your traffic runs, plus tablets and in-app browsers
- Logged-in, returning, populated-cart and discount states, each walked as a real purchase
- Granted, denied and mid-session-changed consent walked separately, each under different rules
Reconciliation against the ledger
- Analytics purchases and revenue set against the order export for the same window
- Refunds, cancellations, test orders and offline channels separated, not absorbed
- A stated and explained ratio, so future readouts have something to be held to
Integrity while a test runs
- Split ratio checked on day one and again as the traffic mix moves
- Non-customer traffic filtered where the platform allows, named where it does not
- A written record of what was checked and when, so nobody after you starts cold
Sample ratio mismatch, treated as a gate not a footnote
Sample ratio mismatch is the closest thing experimentation has to a smoke alarm. You configured an even split, the tool delivered something off it, and across a large sample the odds of that by chance collapse. It does not say what broke. It says the result is not one.
The mistake is checking at the readout, when the deck exists and a failed ratio becomes a caveat everyone ignores. We check on day one and again as the mix moves. Run it yourself with our free SRM checker; the longer piece on what causes a mismatch covers redirects losing people in transit, uneven bot arrival, and caching that serves one arm from an edge node.
The last of those is where bot traffic and split integrity meet. Google Analytics already removes known bots and spiders automatically, using its own research alongside the IAB International Spiders and Bots List, and documents that you can neither switch that off nor see what it took. Everything wearing a real browser string is still there, and rarely splits evenly.
How it runs
Four passes, in this order
Each pass narrows what the next has to look at, which is the only reason the order matters.
- 1
Write down what should happen
We take your test plan, key events and platform setup and state what correct measurement looks like before opening anything. Checking against an unstated expectation is how a broken funnel passes.
- Events mapped to the elements firing them
- Platform and data-layer setup read first
- The expected numbers committed to paper
- 2
Watch it happen
Live sessions on real hardware with the event stream open, walking the journeys that carry money and the failure paths customers take.
- Real devices, not an emulator alone
- Both arms walked identically
- Back-navigation and error paths included
- 3
Reconcile against orders
Analytics purchases and revenue against the store export for the same window, with refunds, cancellations and test orders pulled out rather than averaged away.
- Transaction identifiers deduplicated
- Non-customer orders removed, not estimated
- The remaining gap explained, not rounded
- 4
Hand over something actionable
A written list of what is wrong, what each fault costs in read accuracy, and the fix, ordered so the cheapest correction with the largest effect comes first.
- Findings ranked by effect on decisions
- A named fix attached to each one
- Written for your developers, not for us
Where this sits, and when you want the wider thing
This is one layer of a testing programme, bought on its own, by people who already run one and have stopped believing the readouts. Nothing asks you to change tools or hand anything over.
If the builds are the bottleneck instead of the measurement, A/B test development is the page you want, with this validation folded into each build. If the variations have to leave the browser entirely, server-side experiments changes what can be measured and how, with its own failure modes.
The answers to your questions.
The reliable tell is disagreement between two systems that ought to agree: your testing tool and your analytics reporting different conversion counts for the same experiment, or your analytics and your order admin never reconciling. Two more are worth acting on the same day. One arm reporting far fewer of a mid-funnel event usually means a listener died when the variation replaced a node. And a split that drifts from the one you configured says the measurement is wrong before it says anything about the idea.
Yes, and that is the usual case rather than the exception. Most of this work is done on builds we did not write, for teams who have a programme running and have stopped believing what it tells them. Nothing needs migrating and no tool changes hands. We will also say plainly when the instrumentation is sound and the real problem is test design.
It removes measurement unevenly, and the unevenness matters more than the volume. Where analytics storage is denied, Google tags stop writing cookies and fall back to a restricted mode, with URL passthrough documented as the way to keep continuity across pages. The problem starts when the banner paints at a different moment on each arm: the halves are then measured under different rules, and the difference you read includes that.
No, and the difference is the question each is held to. An analytics audit asks whether your reporting is set up sensibly in general: naming conventions, channel groupings, attribution windows. This asks something narrower and harder, which is whether one specific experiment can be trusted to say which version sold more. A store can pass a thorough analytics audit and still be unable to read a test.
A written findings document, not a dashboard login. Each finding names what fires wrongly, where, in which state, what it costs you in read accuracy, and the fix. The cheapest correction with the largest effect sits first, so a team with one afternoon spends it well. If you would rather we implemented the fixes as each test ships, that is the wider build service, quoted separately.
Not sure whether to trust your last result?
Tell us what the test was, what tool ran it and what the readout claimed. We will name what we would check first, and say if a pass is not worth buying.
Tell us what the numbers are doing ↗