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

Checklists

GTM Container Publish Checklist

A pre-publish checklist for Google Tag Manager: workspace changes, naming, triggers and data layer, preview and consent tests, version notes and rollback.
Checklistintermediate6 min readUpdated

When to run this checklist

Run it every time a workspace is about to be published as a new container version, with no exception for the one-line change: a renamed trigger or a tidied variable is exactly the edit that silently detaches a conversion tag. Run it in full when the change touches anything that feeds bidding or revenue reporting, such as a purchase, lead or key event tag, because an error there teaches an ad platform's bidding the wrong lesson before anyone reads a report. It also applies when a version is created without publishing and released later through an environment; tick the publish group at the moment of release, not at the moment the version was created.

This list is the per-version gate. The periodic clean-up of a container that has drifted is a different job, covered by the audit routine in the governance guide, and proving that tracking works end to end across GA4, Google Ads and Meta is the tracking verification checklist. Run that one too when the version adds or changes a conversion. A version that replaces hard-coded tags also needs the old code removed in the same release, which the tutorial on moving hard-coded tags into Tag Manager plans tag by tag.

Before you start

  • The ticket or request that the change answers, with the pages and actions it affects.
  • The workspace description, written before testing, saying what changes and why.
  • The tracking plan, so new event and parameter names can be checked against it rather than invented.
  • A written test scenario for each affected journey: the page, the action, what should fire and what should not.
  • Two browsers or profiles, one clean, for testing consent states without old cookies.
  • The reviewer, booked, if the container's rules require a second person before publishing.

The checklist

The groups follow the order of the job: check the workspace, check what was built, test it, publish it, and tidy up after. Nothing in the publish group is ticked until every line above it is. If the change is urgent, the groups do not shrink; the review simply happens faster.

0/15

Workspace

Tags and triggers

Preview

Publish

After publishing

Where each check is explained

The widget above keeps the lines short so they can be ticked; the reasoning lives in the guides. Each check links to the page that explains it.

CheckExplained in
Update the workspace with the latest published versionContainers and workspaces
Review the change list against the intentionContainers and workspaces
Keep other people's unfinished changes outContainers and workspaces
Name by the container conventionContainer governance
Changed triggers fire only where intendedTags, triggers and variables
Data layer variables return valuesGTM data layer variable undefined
Each tag fires once in previewDebugging with preview mode
Events and parameters arrive in DebugViewGA4 through GTM
Tags wait for consentGTM tags firing before consent
Custom HTML holds no personal data or unapproved vendorsTag governance
Version name and notesContainer governance
Second review before publishingContainer governance
Previous live version noted for rollbackContainers and workspaces
Real-time check on the live siteGTM tag not firing
Tracking plan updatedTracking plans

If an item fails

Do not publish, and do not publish "just this part". A workspace is published whole, so a failure anywhere holds the version. Fix the line, then rerun its group and the preview group, because almost every fix changes what preview should show. A workspace that has fallen behind the live version needs updating and a fresh preview pass, since the merge can change the very tags that were tested.

Some failures are not fixable in the time available and should be split out instead. If the change list contains an edit nobody can explain, move the intended change to a fresh workspace and leave the mystery for its author. If a consent test fails, the change waits until the tag's consent settings are corrected; a tag that fires before consent is a privacy problem first and a Consent Mode problem second. If a Data Layer variable is empty on some page types, the fix may sit with the developers who own the data layer rather than in the container, and the tag should not be published to fire on those pages with empty values.

If something goes wrong after publishing, the version noted in the publish group is the way back: publish it, confirm in real time that the old behaviour has returned, and then investigate in a new workspace. Rolling back first and diagnosing second is almost always cheaper than diagnosing on the live site.

Illustrative example — not a real result

A bike-parts shop's checkout tag change

An online bike-parts shop adds a tag that sends a "begin checkout" event to its analytics property. The workspace passes preview on the basket and checkout pages, but the change list shows two edits nobody expected: a trigger used by the Google Ads purchase tag has been renamed and its page condition rewritten. The analyst moves the new tag into a fresh workspace, publishes it with a version note naming the tag and the pages, and records the previous live version number in the ticket. The trigger edit turns out to belong to a colleague's unfinished work on a returns page. Had both gone out together, the purchase tag would have stopped firing on the confirmation page, and the shop's bidding would have spent several days optimising against no conversions.

Common mistakes

  • Publishing from a stale workspace. Another workspace was published in the meantime, the merge was accepted without a fresh preview, and the tested version is not the one that went live.
  • Testing only the journey the change was for. The new trigger also fires on the search results page, and nobody looked there.
  • Testing consent in a browser that already accepted. Every tag waits for consent in theory and fires at once in practice, because the test browser said yes weeks ago.
  • Version names that are numbers. When a metric moves a week later, the version history cannot say what changed, and the rollback becomes guesswork.
  • Reviewing the summary, not the tags. The reviewer reads the workspace description and approves, without opening the trigger whose edit affects three other tags.
  • Leaving the tracking plan behind. The container and the plan disagree after the release, and the next person builds on the plan.

The tracking verification checklist is the companion list for proving the result across platforms, and the checklists library holds the rest.

Terms used on this page

Where this page is used

Also related

Sources

  1. Google Tag Manager Help — Google Tag Manager Help
  2. Preview and debug containers — Google Tag Manager Help
  3. The data layer — Google Tag Platform

Related