When to run this checklist
Run it before the first cutover from browser tags to a server-side Tag Manager container, and again each time a new client or destination is added to a server container that is already live: a Meta Conversions APIServer-side event sharing with Meta. tag, a Google Ads conversion tag, a new analytics stream. Each of those is a small cutover of its own, with the same risks of double counting and unfiltered data.
The list is normally run by the person who built the server container, with the developer or platform owner who runs the hosting for the infrastructure group and the ad platform owners for the destinations group. It is a gate, not a fault-finding guide. If the server container is already live and receiving nothing, the server-side GTM not receiving data guide is the place to start. Proving that browser tracking works end to end before anything moves is the tracking verification checklist; run that first, because a server container faithfully forwards whatever the browser sends it, errors included.
Before you start
- A verified browser setup: the current tags proven against the tracking plan, so there is a known-good baseline to compare the server against.
- The server container and its endpoint, with the subdomain and the hosting account named.
- The web container change that routes events to the server endpoint, in a workspace, not yet published.
- A list of destinations and, for each, which fields it should receive and which it must not.
- Access to each destination's diagnostics: analytics DebugView, Meta Events Manager and the Google Ads conversion diagnostics.
- A date range for the parallel run agreed with the people who read the reports, so nobody is surprised by doubled numbers in a dashboard that reads both.
The checklist
The groups follow the path of an event: the server it lands on, the way it flows through, the destinations it reaches, and the cutover that retires the old route. The cutover group is ticked last and only after the destinations group has passed for the whole parallel run, not on its first day. Agreeing the length of the parallel runRunning the old and new versions of a process, platform or tag set side by side for an agreed period, compared on one measure, before the old one is retired. beforehand also stops it being cut short once the first numbers look right.
Infrastructure
Data flow
Destinations
Cutover
Where each check is explained
The widget keeps each line short enough to tick; the reasoning sits in the guides. Each check links to the page that explains it.
| Check | Explained in |
|---|---|
| Serve the tagging server from a first-party subdomain | Server-side tagging basics |
| Name an owner for hosting, scaling and running costs | Server-side tagging basics |
| Restrict who can publish the server container | Container governance |
| Confirm the web container sends events to the server endpoint | Server-side GTM not receiving data |
| Check each client claims the requests it should and no others | Server-side GTM not receiving data |
| Strip or hash personal data the destinations must not receive | Privacy, consent and measurement |
| Pass the consent state through to every server tag | Consent mode |
| Compare analytics events from server and browser during a parallel run | Server-side tagging basics |
| Deduplicate Conversions API events against the browser pixel | Meta Conversions API duplicate events |
| Confirm enhanced conversions data arrives in Google Ads | Enhanced conversions not working |
| Check event match quality for server events in Meta | Low event match quality on Meta |
| Run browser and server tags side by side before removing the old tags | Server-side tagging basics |
| Keep the previous web container version ready to restore | Containers and workspaces |
| Annotate the cutover date in analytics and ad platforms | Marketing data quality |
If an item fails
A failure in the data flow group stops the cutover. If personal data reaches a destination that should not receive it, or server tags fire without the visitor's consent state, the server container is doing exactly what the browser setup was trusted not to do, and the fix comes before any traffic moves. Hashing is not a substitute for consent: a hashed email address sent without permission is still sent without permission.
Destination failures usually hold the destination, not the whole project. If DeduplicationRemoving double counts when one conversion is reported by more than one source. against the Meta pixel is not working, keep the Conversions API tag paused and let the pixel carry conversions until the shared event identifier matches; a double-counted purchase teaches the bidding to chase conversions that never happened. If Enhanced ConversionsA Google Ads feature that sends hashed first-party customer data to improve conversion matching. data is not arriving, the Google Ads conversion tag can stay in the browser while the server tag is fixed. Each destination can be cut over on its own once it passes. The academy exercise on a riding equipment retailer's server-side cutover practises sequencing analytics, Meta and Google Ads through this gate one after another, each browser copy kept until its server copy passes and nothing moved during the retailer's busiest weeks.
Infrastructure failures are rarely visible at launch and expensive later. A tagging server on the hosting provider's default domain works at launch and loses most of the first-party benefit; a server with no named owner works until the bill or the traffic spike arrives. Fix both before the cutover, since moving the endpoint afterwards means another parallel run. If the cutover itself goes wrong, publish the previous web container version recorded in the cutover group, confirm the browser tags are back, and investigate the server container in parallel.
A coffee roaster's move to server-side tagging
Carrowmoor Coffee Roasters, a subscription coffee business, moves its analytics and Meta tags to a server container on a first-party subdomain. The data flow group passes, but the destinations group fails during the two-week parallel run: Meta reports about one and a half purchases for every order in the shop's back office. The browser pixel and the server tag send the same purchase with different event identifiers, so nothing is deduplicated. The Conversions API tag is paused, the order number is passed as the shared identifier in both, and the parallel run restarts. A week later Meta's purchase count matches the back office closely, and the browser purchase tag is removed with the previous web container version noted in the change log.
Common mistakes
- Cutting over without a parallel run. The old tags are removed on the same day the new ones go live, so there is no baseline to show whether anything was lost.
- Assuming the server fixes bad data. A server container forwards what the browser sends; a broken data layer is still broken one hop later.
- Forwarding everything to everyone. The server receives the full event and passes it on unfiltered, including fields a vendor was never meant to see.
- Forgetting consent on the server side. The browser respects the banner, the server tags do not read the consent state, and tags fire for visitors who refused.
- No owner for the hosting. The server scales, the bill grows, and nobody is watching either.
- Silent cutover. The date is not annotated, and next month's change in reported conversions is blamed on the campaigns.
The tracking verification checklist is the list to run before and after the cutover, and the checklists library holds the rest.
