Skip to content
Faisal Mahmud TusherDigital marketing, SEO & analytics
with Faisal Tusher

Checklists

Server-Side Tagging Go-Live Checklist

A go-live checklist for server-side tagging: first-party endpoint, client and data flow, personal data and consent, deduplicated destinations and cutover.
Checklistadvanced6 min readUpdated

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 API 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 run beforehand also stops it being cut short once the first numbers look right.

0/14

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.

CheckExplained in
Serve the tagging server from a first-party subdomainServer-side tagging basics
Name an owner for hosting, scaling and running costsServer-side tagging basics
Restrict who can publish the server containerContainer governance
Confirm the web container sends events to the server endpointServer-side GTM not receiving data
Check each client claims the requests it should and no othersServer-side GTM not receiving data
Strip or hash personal data the destinations must not receivePrivacy, consent and measurement
Pass the consent state through to every server tagConsent mode
Compare analytics events from server and browser during a parallel runServer-side tagging basics
Deduplicate Conversions API events against the browser pixelMeta Conversions API duplicate events
Confirm enhanced conversions data arrives in Google AdsEnhanced conversions not working
Check event match quality for server events in MetaLow event match quality on Meta
Run browser and server tags side by side before removing the old tagsServer-side tagging basics
Keep the previous web container version ready to restoreContainers and workspaces
Annotate the cutover date in analytics and ad platformsMarketing 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 Deduplication 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 Conversions 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.

Illustrative example — not a real result

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.

Terms used on this page

Where this page is used

Part of these learning paths

Also related

Sources

  1. An introduction to server-side tagging — Google Tag Platform
  2. About the Conversions API — Meta Business Help Centre
  3. About enhanced conversions — Google Ads Help

Related