Google, Facebook Ads

How I Set Up Google Tag Manager for sigmalaunch.com

Set up Google Tag Manager from scratch for your website with this beginners guide. Understand GTM's hierarchy and implement conversion tracking without touching your website code again.

Sep 10, 2025

When I first started setting up Google Tag Manager (GTM) for sigmalaunch.com, I realized how confusing all the moving pieces can be. Do I need GTM and the Google tag? Is a “conversion linker” different from a conversion tag? Where do “containers” and “triggers” fit into the puzzle?

So I decided to write this step-by-step guide from my own experience — not just to document how I set up GTM for SigmaLaunch, but also to make it easier for anyone else starting from scratch.

While setting up Google Tag Manager (GTM) for SigmaLaunch.com I had three goals:

stop scattering tracking scripts across the code of my website,
make it easy to add or change tracking without a developer every time, and
make sure conversions were attributed correctly to Google Ads (no phantom or duplicate conversions).

This guide is the exact, detailed walkthrough I used — plus the background/context I wish someone had explained to me before I started. If you’ve ever opened GTM and felt lost, this breakdown is for you.

Why Google Tag Manager Exists

Before GTM:

You had to paste tracking code for every tool (Google Ads, Analytics, Meta Pixel, etc.) directly into your website.
Every change required editing site code. If you wanted to track something new, you’d call a developer.
Mistakes meant broken tracking and wasted ad money.

This caused:

many duplicate or conflicting tags,
slow iteration for marketers, and
a brittle, developer-dependent process.

GTM solves this by becoming the single source of truth for client-side tags. You install one GTM container snippet on your site, and GTM becomes the place where you configure all tracking—Google Ads, GA4, Meta, LinkedIn, Hotjar, and custom scripts.

With GTM:

You paste one container code into your site once.
After that, you can add and manage all your tracking codes (tags) inside GTM’s dashboard — without touching website code again.
That reduces mistakes, increases speed, and centralizes governance (naming, versioning, testing).

Important context points I learned the hard way:

GTM does not replace Analytics or Ads — it simply delivers tags that send data to those platforms.
Good GTM practice is also governance practice: strict naming conventions, staging environments, and a testing workflow prevent lots of tracking mistakes.
If you already have gtag.js or other tags hard-coded, you need to decide whether to migrate them into GTM (recommended) or keep them — but don’t run both in ways that duplicate events.

Hierarchy + Deep Dive on Tag Universe

Container → Tags → Triggers → Variables (+ dataLayer & environments)

Think of GTM as a filing cabinet. Below is the complete, detailed map of what lives where, what it does, and why it matters.

Google Tag Manager (the cabinet)

Container (a drawer in the cabinet, installed on your website)
- Tags (the documents inside the drawer)
  - Example: Google Ads Conversion Tag
  - Example: GA4 Pageview Tag
  - Example: Meta Pixel Tag
- Triggers (the post-it notes attached to each document telling when it should be used)
  - Example: Fire only on the thank-you page
  - Example: Fire when a form is submitted successfully
- Variables (the little helpers that provide details to triggers or tags)
  - Example: “Page URL” variable checks which page you’re on
  - Example: “Form ID” variable checks which form is being submitted

1. Container

What it is: a container is the single snippet of GTM code you place on a site. It holds your tags, triggers, variables, workspaces, versions, and environments.

Where it sits on the site: the container provides two small snippets GTM asks you to paste:

one into the <head> and
one immediately after the opening <body> tag.
(Place them exactly where GTM tells you so it loads correctly — many CMSs and plugins provide a header/footer insertion area.)

What it does: once installed, that container snippet downloads the GTM “app” and enables GTM to inject tags per your configuration. The container is the only site-level code change you should need for most tracking.

Why details matter:

If the snippet is missing from a page, none of the tags in that container will run on that page.
If you accidentally paste a container twice (or a previous gtag + GTM that both send the same events), you get duplicate events. So 1 lead will count as 2 leads, for example.

2. Tags

What a tag is: A tag is the piece of code that executes when its trigger conditions are met. Tags live inside the container (they are configured in GTM, not pasted on the site). Examples: Google Ads conversion, GA4 config, Facebook Pixel, custom HTML, third-party templates.

Types of tags in GTM

Built-in templates: Google Ads, Google Analytics, LinkedIn, Facebook, etc. (best to use these when available — they manage specifics for you).
Custom HTML Tag: paste any raw JavaScript/HTML (useful for third-party widgets or code without a template).
Custom Image Tag: for firing pixels that are just image requests.

Where they reside: Within the GTM container UI. Each tag has configuration fields, e.g., for Google Ads: Conversion ID + Label. For GA4: Measurement ID.

Purpose: Tags send data to external systems. They are the “actors” — they do the work (send events, set cookies, load pixels).

3. Triggers

What a trigger is: a condition or set of conditions that tells GTM to fire a tag. Think of triggers like event listeners.

Common trigger types and when we use them

All Pages (Page View) — for base tags like GA4 config or remarketing pixels that should run on every page.
Page View → Some Page Views — when you need to run a tag only on certain URLs (like /thank-you).
Click → All Elements / Just Links — when you want to fire on specific button or link clicks. Use Click Classes or Click Text variables to target precisely.
Form Submission — native form submit events (but be careful: it detects attempts to submit, not necessarily success). For AJAX forms, prefer Custom Event or dataLayer triggers.
Element Visibility — fires when an element appears in the viewport (good for lazy-loaded content or detecting when a success message becomes visible).
Custom Event — fires when the site pushes an event into dataLayer
History Change — for single-page apps (SPA) where URLs change without page reloads.

Why precision matters: using broad triggers (e.g., generic form submit) can cause false positives (tracking a submit event even when validation blocks the submission). I always test triggers extensively in Preview mode.

4. Variables — the small helpers tags & triggers use

What variables do: Carry contextual values used by triggers or tags. They’re placeholders for data like page URL, click text, or values pushed into the dataLayer.

Types of variables:

Built-in variables: Page URL, Click Classes, Form ID, Referrer, etc. Enable what you need.
User-defined variables: Data Layer Variable, JavaScript Variable, DOM Element, URL variable (for extracting query params), etc.

Example: I use a Data Layer Variable named transactionId that reads transactionId from dataLayer for e-commerce purchases. Then my Google Ads conversion tag uses that variable for deduplication/parameterising.

5. dataLayer — the contract between your site and GTM

What it is: dataLayer is a JavaScript array (window.dataLayer = window.dataLayer || [];) used to push structured events and data to GTM.

Why it’s used: for reliable, precise tracking — especially for AJAX forms, purchases, or any event that requires additional metadata (order value, product IDs, user type). Skip this as a beginner.

Best practice: push events from the application code (the developer should push); avoid trying to scrape UI state from the DOM because it’s fragile.

6. Workspaces, Versions, and Environments

Workspaces: let multiple people make changes concurrently. I use one workspace per feature or change.
Versions: every Publish creates a version. Use version descriptions to document releases (e.g., “GA4: add purchase event — 2025-09-09”).
Environments (Live/Debug/Staging): I use at least two environments. QA the container in staging before pushing to production. GTM supports publishing to named environments.

Google’s Tags

Before we jump into specific tags you’ll create, let’s describe what “Google’s tags” are as a whole — because that confusion is the most common. In simple terms:

“Google tags” = the family of Google-supplied scripts that connect your site to Google properties (Ads, Analytics, Floodlight, etc.). They’re special because Google provides templates inside GTM that handle platform-specific details for you.

Here’s the lineup and how I think about each:

1. The Google Tag (the global site tag / gtag.js)

What it is: Google’s universal snippet historically called gtag.js (global site tag). Google sometimes refers to the modernized wrapper as the Google Tag.
Purpose: it’s the base connector — ties your site to Ads, GA4 and other Google services if installed directly.
With GTM: you usually do not paste gtag.js on the site if you’re using GTM. Instead, you implement an equivalent via a GTM “Google Tag” or GA4/Ads tags. Running both GTM and a separate gtag can cause duplicate hits.

2. GA4 — Configuration & Event tags

GA4 Configuration tag: initializes GA4 (Measurement ID) and should fire on All Pages.
GA4 Event tags: used for custom events (e.g., purchase, sign_up). I often use GTM to send custom events to GA4 so I can control naming and parameters centrally.

3. Google Ads Conversion Tracking Tag

What it does: reports conversions (form fills, purchases) to Google Ads. Requires Conversion ID + Conversion Label from the Ads UI.
Where it lives: as a Google Ads Conversion Tag in GTM.

4. Google Ads Remarketing Tag

Purpose: build remarketing audiences. Often fired on All Pages so every visitor is taggable.

5. Conversion Linker Tag

Why it exists: when a user clicks an ad, Google attaches click identifiers (e.g., gclid) to the landing URL. The Conversion Linker sets a first-party cookie so Google Ads can later attribute conversions back to the click.
How I use it: Always add Conversion Linker on All Pages when using Google Ads (via a simple GTM tag). This dramatically reduces lost attribution.

6. Floodlight (Campaign Manager / DV360)

For advanced advertisers using Campaign Manager/Display & Video 360 — not typical for small sites, but worth noting.

7. Enhanced Conversions (server or client)

Optional upgrade: send hashed conversion data (email, phone) to improve match rates. Setup can be client-side or server-side; many teams implement server-side GTM for this.

Understanding the Terminology of Tags

I’ve seen the same confusions over and over — so I wrote down the exact differences and consequences:

A — Google Tag Manager vs Google Tag

GTM = the manager/container. You administer tags, triggers, variables, versions, and publish from the GTM UI.
Google Tag (gtag.js) = Google’s global site tag. If you’re not using GTM, you paste gtag.js directly into your pages to talk to Google Ads/GA4.
Rule: If you plan to manage tags via GTM, don’t also keep gtag.js hard-coded.

B — Google Tag vs Google Ads Conversion Tag

Google Tag = the base/global connector (if implemented directly).
Google Ads Conversion Tag = a specific action that reports a conversion to Google Ads (requires conversion id/label).
Consequences: having only a Google Tag (global) on all pages does not automatically send conversion events — you must also define and fire a Conversion Tag (or send conversion events via GA4) to record conversions in Ads.

C — Google Ads Conversion Tag vs Conversion Linker

Conversion Tag records the conversion event (what happened).
Conversion Linker helps attribute the conversion to the correct ad click by storing click identifiers in cookies.
Always do both: conversion tag without a linker frequently yields lost attribution; linker without conversion tag yields no recorded conversions. They complement each other.

D — Google Tag in Google Ads vs Google Tag in GTM

In Google Ads UI, when you choose “Install the tag yourself,” it will show a snippet (the global site tag) that you paste to the site.
If you’re using GTM, you don’t paste that snippet — you select the Google Tag template (or use GA4/Ads tag templates) and enter the IDs. GTM becomes the vehicle for that functionality.
UX tip: If Google Ads offers a direct snippet, you can either: copy that snippet into your site (not recommended if you plan to use GTM) or use the values (IDs) and configure a GTM tag.

First-time setup — Exactly what I did for Sigma Launch (with debugging & checks)

This is the exact sequence of steps I followed — debugging along the way.

Pre-setup checklist

Admin access to GTM (tagmanager.google.com).
Edit access to the website HTML/CMS (or a developer who will paste the container).
Google Ads account access (to create conversion actions and get IDs).
GA4 property (Measurement ID) if you want analytics in GTM too.
A test/staging URL if possible (recommended).

Step 1 — Create GTM account & container and install the snippet

Create an account (I named it SigmaLaunch).
Create a Web container for the domain.
GTM gives you two snippets: paste the first into the document <head> and the second immediately after the opening <body>.
- Example placeholder (do not paste this directly — use your GTM-provided code):

<!-- GTM head snippet -->
<script>/* GTM head code with container ID */</script>

<!-- GTM body snippet -->
<noscript><iframe src="<https://www.googletagmanager.com/ns.html?id=GTM-XXXXX>"></iframe></noscript>

If using WordPress, use a trusted plugin or paste into header.php/footer.php with care. Avoid plugins that inject GTM twice. Confirm only one container snippet exists per page.

Checks after install:

Open your site and view source to confirm both snippets are present.
Try GTM Preview. If GTM preview cannot connect, confirm no CSP or server headers block GTM requests.

Step 2 — Create & publish a minimal baseline in GTM

I created and published a small baseline so Preview mode is useful:

Google Tag (with ID - refer below) — Trigger: All Pages
Conversion Linker Tag — Trigger: All Pages
Save and Publish (or at least create the workspace with these tags and test in Preview).
GTM allows a “Preview” mode - go to Preview and it opens a Tag Assistant. The Tag assistant shows if the tag is correctly implemented and fired on page load.

Step 3 — Add Google Tag to GTM (gtag.js equivalent inside GTM)

Where it comes from: Google Ads or GA4 UI will show you the “global site tag” (gtag.js) if you opt to install manually. The snippet includes your IDs.

How I handled it: Instead of pasting that snippet into my site, I used GTM:

In GTM: New Tag → choose the Google Tag → paste your Google Tag IDs into the template fields → Trigger: All Pages.

Why this is better: GTM handles loading and avoids duplicate tag code on the page. I made the mistake of initially ddinggtag.js hard-coded in the website header, I removed that snippet to prevent double-counting, and let GTM manage firing the equivalent tags.

Step 4 — Add Google Ads Conversion Tag

In Google Ads: create a Conversion action (type = Website). You’ll receive Conversion ID and Conversion Label (or instructions for GTM).
In GTM: New Tag → Google Ads Conversion Tracking → paste Conversion ID + Label.
Create a trigger (see Step 5). I named the tag GoogleAds | Conversion | ContactForm TY.

Step 5 — Create triggers

If you have a thank-you page (simplest and most reliable):

Create a Page View → Some Page Views trigger where Page URL contains /thank-you.

If you want to track link clicks:

Create a Links Click → Some Links trigger where you can add filters based on Click Text or other click parameters

If you do NOT have a thank-you page (AJAX form or SPA):

Ask devs to dataLayer.push({event: 'contactFormSuccess', formId: 'contactForm'}) on success.
In GTM create a Custom Event trigger for contactFormSuccess. Map required variables (value, transaction id) via Data Layer Variables.

If the site shows a success message DOM element:

Use Element Visibility trigger with CSS selector for the success message.

Step 6 — Test in GTM Preview Mode

In GTM, click Preview. Enter your site’s URL. This opens the Tag Assistant window and a connected browser tab for your site.
Perform the action (visit the thank-you page or submit the form).
Inspect Tag Assistant’s left column for the event stream (e.g., gtm.js, gtm.dom, contactFormSuccess).
Select the event and check what tags fired and which didn’t — GTM shows you details, variables, and the dataLayer contents.

What I check in Preview:

Does the Google Tag fire on gtm.js (page load)?
Does the Conversion Linker fire on All Pages?
Does the Google Ads Conversion tag fire on the custom event or thank-you page?
Are the variables (e.g., transactionId, value) present and correct in the dataLayer?

Notes

The Tag Assistant also has an option to select Tag on top. By default select the “Container” to see all tags fired. But you can also see Tags fired within Google Ads or other apps.

Use Tag Assistant extension

Install Tag Assistant (by Google) Chrome extension to validate tags and diagnose common misconfigurations.

Step 7 — Publish and verify in Ads / GA4 (post-publish checks)

After publishing the GTM container (Submit → Publish with a descriptive version message), run the same test in Preview/Live to ensure it behaves the same.
Confirm the conversion fired (GTM Preview shows it). For Ads/GA4, you may not always see the conversion instantly in reporting; use Debug views and Tag Assistant to confirm the event reached the platform.

Troubleshooting Checklist

Tag fired in GTM Preview, but Ads/GA4 didn’t record: check Network tab for the outgoing request; confirm Conversion ID/Label or Measurement ID are correct; verify Conversion Linker cookie exists.
Conversion fires on validation errors: Trigger is too broad. Use a success dataLayer push or thank-you page instead of form submit.
Duplicate conversions: You have duplicate tag implementations (hard-coded gtag + GTM). Remove one. Use unique event IDs for deduplication where possible.
Preview won’t connect / blocked: check ad blockers, cookie consent banners, or Content Security Policy (CSP) — these can block GTM or tags. Test with extensions disabled.

Optional Upgrades

Enhanced Conversions / Server-Side GTM: if match rates are low or ad blockers are a problem, consider server-side tagging.
Cross-domain tracking: if purchase flows span domains, configure linker and cross-domain settings.
Audit occasionally: run an audit quarterly to remove stale tags and keep your container lean.

Wrapping Up

Setting up GTM felt overwhelming at first — so many tags, snippets, and “linkers.” But once I understood the hierarchy, it clicked:

Container → Tags → Triggers → Variables

GTM holds everything.
Containers sit in your site’s code.
Tags fire tracking codes.
Google’s tags are just one family of tags, with some specific rules.
- Google Tag (gtag.js) = the universal script if you’re not using GTM
- Inside GTM, you add Google Ads, GA4, remarketing, and other Google tags directly as tag types

Google Tag Manager isn’t magic — it’s a structured way to manage all your tags without messing with code.

Start small: track one Google Ads conversion. Once that works, adding GA4, Meta Pixel, or LinkedIn Insight becomes just a few clicks.

The golden rule: Always test in Preview mode before publishing.

Now SigmaLaunch is fully connected with GTM, Google Tag, Conversion Linker, and conversion tracking — and I can easily add more tags later without ever touching my website’s code again.

Checklist I used for sigmalaunch.com

Installed GTM container in head + body
Google Tag added (All Pages)
Conversion Linker added (All Pages)
Conversion action created in Google Ads (grab Conversion ID + Label)
Google Ads Conversion Tag added to GTM (fires on Book a Call button click)
GTM Preview verified tags fired on both GTM and Google Ads
Published GTM container with Version note: “GA4 + Ads baseline + Lead conversion — SigmaLaunch”