You spent hours setting up event tracking, configuring triggers, and mapping out your measurement plan. Everything looks right in Google Tag Manager. You publish your container and move on. But here’s the question that separates good analysts from great ones: how do you know it’s actually working?

Debugging is the most overlooked step in analytics implementation — and it’s the one that matters most. After debugging hundreds of GA4 implementations, I can tell you that roughly 30% of tracking setups have at least one silent failure. Events that never fire. Parameters that arrive empty. Duplicate transactions that inflate revenue.

This guide walks you through a complete debugging workflow using GTM and GA4’s built-in tools. You’ll have a repeatable process by the end.

Why Debugging Matters

Bad data doesn’t just sit in your reports — it drives decisions. I’ve seen companies reallocate six-figure ad budgets based on attribution data that was double-counting conversions. I’ve watched teams kill high-performing landing pages because a broken event made the conversion rate look like zero.

There are three moments when debugging is non-negotiable:

• After initial setup — validate every event in your tracking plan fires correctly
• After any change — new tags, updated triggers, website redesigns, consent tool updates
• When numbers look wrong — sudden drops, unexpected spikes, or contradictory data

Your Debugging Toolkit

You don’t need expensive third-party tools. Google gives you everything:

GA4 DebugView — shows events in real time as they arrive from debug-enabled devices, with full parameter details. Find it under Admin → DebugView.

GTM Preview Mode — connects to your site and shows which tags fired, which didn’t, what triggered them, and the full dataLayer state. This is where you’ll spend most of your time.

Google Tag Assistant — the Chrome extension that powers GTM Preview mode. Also works independently to verify tags on any site.

Browser DevTools (Network tab) — the raw truth. Every GA4 hit passes through here. When other tools disagree, DevTools is the final authority.

GA4 Realtime Report — shows data arriving within seconds. Less detailed than DebugView but useful for quick sanity checks.

Step 1 — Enable Debug Mode

Before you can see events in DebugView, tell GA4 your device is in debug mode. Three methods:

Method 1: GTM Preview Mode (recommended). Click “Preview” in GTM and connect to your site. Debug mode is automatically enabled. I use this 90% of the time.

Method 2: Chrome Extension. Install Tag Assistant Companion. It adds debug_mode=true to your GA4 requests automatically. Works even without GTM.

Method 3: Code Parameter. For gtag.js implementations:

gtag('config', 'G-XXXXXXXX', {
  'debug_mode': true
});

Important: remove debug_mode: true from production code. Leaving it on means every visitor’s events flood your DebugView.

Step 2 — Use GTM Preview Mode

GTM Preview mode is the most powerful debugging tool. Open your container, click Preview, enter your URL, and connect. Navigate your site and perform the actions you want to debug.

In the Tag Assistant panel, you’ll see a timeline of events. Click any event to see:

Tags Fired / Tags Not Fired — if your GA4 event tag is under “Tags Not Fired,” the problem is your trigger. Click the tag to see which conditions failed.

Variables — check every variable value at the moment the tag fired. This catches undefined dataLayer variables, wrong CSS selectors, and URL matching problems.

DataLayer — the raw dataLayer state after each event. Essential for custom event tracking that relies on dataLayer pushes. If the push isn’t there, the problem is on the website side.

Pro tip: click “Tags Not Fired” on your trigger event. GTM shows each condition with a green checkmark or red X — instant diagnosis.

Step 3 — Read GA4 DebugView

GTM Preview tells you what’s happening on the sending side. DebugView tells you what’s arriving on the receiving side. Navigate to Admin → DebugView.

Events appear as colored dots on a vertical timeline. Event colors matter:

• Green — standard events GA4 recognizes (page_view, purchase)
• Blue — custom events not in GA4’s predefined list
• Orange — conversion events (events marked as key events)

Click any event to see its parameters and user properties. Check that custom parameters are present with expected values. GA4 is case-sensitive — item_name and Item_Name are different parameters.

Use the device selector in the top left to filter to your specific device — DebugView shows events from all debug-enabled devices.

Step 4 — Check with Browser DevTools

When GTM says a tag fired and DebugView doesn’t show the event, go deeper. Open DevTools (F12), go to Network tab, perform your action. Filter for collect to show GA4 requests to google-analytics.com/g/collect.

Click any collect request and check the Payload tab. Key parameters:

• en — event name
• ep.parameter_name — string event parameters
• epn.parameter_name — numeric event parameters
• tid — measurement ID (verify it’s correct)
• _dbg — debug mode flag (1 = enabled)

If you see no collect requests at all, your consent management tool is likely blocking GA4. Check the Console tab for consent-related messages.

Step 5 — Validate Data in GA4 Reports

DebugView confirms events arrive in real time, but GA4 standard reports have a 24-48 hour processing delay. My validation process:

1. Confirm events appear in DebugView with correct parameters
2. Check the Realtime report for a broader view
3. Wait 24-48 hours and check Engagement → Events report
4. Build a quick Explore report to verify custom dimensions are populating

If events appear in DebugView but not in reports after 48 hours, check two things: first, register your custom parameters as custom dimensions in Admin → Custom Definitions. Second, verify data filters aren’t excluding internal traffic.

Debugging Common Issues

Events not firing. Check GTM Preview’s “Tags Not Fired” section. Nine times out of ten, it’s a trigger condition mismatch — wrong Click URL variable, regex issues, or a dataLayer variable referenced before it’s pushed.

Duplicate events. Two tags with overlapping triggers. Common with page_view — GA4’s configuration tag fires one automatically, plus a separate tag fires another. Also check for duplicate GTM snippets in page source.

Missing parameters. Event fires but parameters are empty. Check Variables tab in GTM Preview at the exact trigger moment. If undefined, the dataLayer push happens after your trigger. Solution: use a Custom Event trigger that waits for the specific push.

Consent mode blocking. Tags may be blocked until consent is granted. In GTM Preview, blocked tags show a “Consent” section with a red indicator. Test with consent granted first.

Cross-domain breaks. Users land on your second domain without the _gl parameter. Check your GA4 configuration tag’s domain list. If you’re using third-party checkout pages, this is one of the most common breaks.

A Debugging Workflow That Works

After debugging hundreds of implementations, here’s my six-step process that catches 95% of issues:

1. Open GTM Preview and connect to your site
2. Walk through every tracked interaction in your tracking plan
3. Verify in GTM Preview: tag fired, correct trigger, expected variable values
4. Switch to GA4 DebugView — confirm each event arrived with right parameters
5. Spot-check in DevTools Network tab for suspicious events
6. Come back in 48 hours — verify events appear in standard reports

I keep a simple spreadsheet alongside my tracking plan with columns for each validation step. It takes an extra hour upfront but saves weeks of firefighting bad data later.

FAQ

Why don’t my events appear in GA4 DebugView?

Debug mode likely isn’t properly enabled. Check DevTools Network tab — filter for collect and look for the _dbg=1 parameter. If missing, try the GA4 Debug extension. Also ensure you’re looking at the correct GA4 property and device.

How long does DebugView retain data?

DebugView shows events from the last 30 minutes only. It’s a real-time debugging tool, not a reporting tool. Events older than 30 minutes disappear from the view.

Can I debug on a staging or localhost environment?

Yes. GTM Preview mode works on staging sites with the same container. For localhost, use the GTM Preview URL connection or the debug_mode parameter in code. Use a separate GA4 property for staging to keep test data out of production.

Do debug events count toward GA4 data limits?

Yes. Debug events are real hits that get processed and appear in reports. The only difference is they also appear in DebugView. Don’t leave debug_mode: true in production code.

What’s the difference between Realtime and DebugView?

Realtime shows aggregated data from all users in the last 30 minutes. DebugView shows individual events from debug-enabled devices with full parameter details. Use Realtime for quick checks, DebugView for detailed validation.

Start Debugging Before It Matters

The best time to debug your tracking is right after setup — not three months later. Every event in your tracking implementation should be validated through GTM Preview, confirmed in DebugView, and verified in reports. That one hour of validation protects every decision made from your data.