You open Google Tag Manager Preview mode, perform the action you want to track, and there it is:
Tag Fired.
Everything looks good.
Then you open Google Analytics 4 and the event is missing.
Or perhaps the event appears while you’re testing, but production data is much lower than expected.
This is one of the more frustrating GA4 troubleshooting situations because GTM appears to be telling you that everything is working.
But there is an important distinction:
A tag firing does not necessarily mean your measurement is working.
GTM Preview tells you that the conditions required to execute the tag were met. You still need to determine whether the data was actually sent, received by GA4, processed correctly, and consistently collected for real users.
Here are some of the most common places to look.
1. Check GA4 DebugView, Not Just GTM Preview
Your first checkpoint should be GTM Preview.
Your second should be GA4 DebugView.
If GTM says the event tag fired but the event never appears in DebugView, you’ve learned something important: the trigger may be working, but the event may not be successfully reaching GA4.
Check basics such as:
- Is the event being sent to the correct GA4 Measurement ID?
- Is the Google tag configured correctly?
- Is the expected event name being sent?
- Are the expected parameters included?
- Is the request actually being sent from the browser?
Think of GTM Preview as confirming what happened inside your tagging setup. DebugView gives you another checkpoint closer to what GA4 is actually receiving.
2. Check Consent Behavior
Consent is increasingly one of the reasons an implementation can behave differently during testing than it does for actual visitors.
For example, your own test session may have analytics consent granted while a significant portion of your visitors have analytics_storage denied.
Consent management platforms can also affect when tags execute and what information gets sent.
That means:
“It worked when I tested it” doesn’t necessarily mean “it works the same way for everyone.”
When investigating missing data, look at the consent state at the time the event occurs and make sure your consent implementation is behaving as intended.
3. Make Sure You’re Testing the Published Container
GTM Preview allows you to test the current workspace before publishing it.
That’s one of its biggest benefits.
But it also creates an easy troubleshooting trap.
You can make a change, enter Preview mode and see the tag work perfectly, while regular visitors are still running the previous published version of the container.
Whenever Preview works but production doesn’t, verify that the correct container version was actually published.
4. Look at the Network Request
Sometimes you need to go one step beyond GTM.
Use your browser’s developer tools and inspect the network activity when the event occurs.
For GA4 browser-side tracking, you should be able to determine whether the expected request is actually being sent.
This helps separate two very different problems:
Problem A: GTM says the tag fired, but no request left the browser.
Problem B: The request was sent, but the resulting data isn’t appearing where you expect it in GA4.
Those require different troubleshooting paths.
5. Check Filters and Reporting Expectations
If the event reaches GA4 DebugView but doesn’t immediately appear in your normal reports, the implementation may not necessarily be broken.
GA4 reporting is not the same thing as DebugView.
Consider whether you’re dealing with:
- Processing delays
- Internal or developer traffic filters
- Reporting configuration
- Data thresholds
- Differences between Realtime and standard reports
This is why troubleshooting should follow the data through the entire measurement chain rather than relying on one screen.
“Tag Fired” Is Only One Checkpoint
A useful way to think about analytics implementation is as a chain:
User action → Data layer → GTM trigger → Tag execution → Network request → GA4 collection → Processing → Reporting
GTM Preview primarily helps you inspect the earlier part of that chain.
Your business decisions depend on the entire chain working.
And that’s why an implementation can look completely healthy inside GTM while GA4 data is incomplete, inconsistent, or simply wrong.
Don’t Just Ask “Did the Tag Fire?”
Ask:
“Can I trust the data this implementation is producing?”
That’s a much more useful question.
A successful test proves that a specific test worked at a specific moment. It doesn’t necessarily tell you whether tracking worked yesterday, whether consent behavior changed, whether someone published a GTM update last week, or whether GA4 data quality has gradually deteriorated.
That requires ongoing measurement quality checks.
This is also the problem we’re working on with GA Auditor.
GA Auditor helps you audit your GA4 implementation and monitor changes in your GA4 and Google Tag Manager setup so you can catch measurement problems that a one-time GTM Preview session may not reveal.
Because ultimately, seeing “Tag Fired” isn’t the goal, trustworthy data is.