Google Tag Manager gives you control over when tracking scripts fire on a page. Use that control poorly and you slow down your site, skew your data, or both. The three built-in trigger types — Page View, DOM Ready, and Window Loaded — exist for a reason, and most GTM setups misuse at least one of them.
The Three Trigger Types
Page View
Fires as soon as the GTM container loads, before the page has finished rendering. This is the earliest possible trigger point.
Use it for: Analytics base tags (GA4, Google Ads global site tag), consent management platforms, and anything that must initialise before the user interacts with the page. These are scripts that set up measurement infrastructure — they need to be present before events happen.
Do not use it for: Conversion pixels, remarketing tags, or third-party scripts that are not needed for initial page measurement. Loading these at Page View blocks rendering and slows the experience.
DOM Ready
Fires when the HTML document is fully parsed and the DOM is built, but before images, stylesheets, and other resources finish loading. The page structure exists; the visual rendering is still in progress.
Use it for: Tags that interact with page elements — form tracking scripts, click listeners, custom event observers, chat widgets. These scripts need the DOM to exist but do not need images or external resources loaded.
Do not use it for: Heavy third-party scripts that can wait. Every script at DOM Ready competes with the browser’s rendering work.
Window Loaded
Fires when every resource on the page — images, scripts, iframes, fonts — has finished loading. This is the last trigger in the sequence.
Use it for: Non-critical tracking pixels, social sharing buttons, heatmap tools, A/B testing scripts that do not affect above-the-fold content, and any tag that is not time-sensitive. Deferring these to Window Loaded keeps them out of the critical rendering path.
Do not use it for: Anything that needs to capture user interactions happening before full page load. If a user clicks a CTA two seconds in and your click tracker fires at Window Loaded four seconds in, you miss the event.
Why This Matters for Performance
Every tag you fire during page load competes for browser resources. A typical enterprise GTM container has 15 to 40 tags. If all of them fire at Page View, you force the browser to download, parse, and execute dozens of scripts before the user sees a complete page. That directly hurts Core Web Vitals — the metrics Google uses as a ranking signal for search rankings.
The fix is straightforward: audit your container, categorise each tag by when it actually needs to fire, and reassign triggers accordingly.
A Practical Audit Process
- Export your GTM container and list every tag with its current trigger.
- For each tag, ask: does this need to run before the page is visible? If no, move it to DOM Ready or Window Loaded.
- Test with GTM Preview mode and Chrome DevTools Performance tab. Verify that critical tags still capture data and that deferred tags do not miss interactions.
- Monitor the impact on page load time using your analytics dashboards and tools like Google PageSpeed Insights.
This is not a one-time exercise. Every new tag added to your container is a potential performance regression. Build trigger discipline into your website management process and review your GTM container quarterly.