You’ve spent hours setting up Google Tag Manager, testing everything with Preview mode, and confidently publishing… only to find something’s wrong in your reports? Maybe events aren’t firing, conversion numbers are odd, or (worse) you have absolutely no data coming through.
While it may seem like something a beginner would do, even those of us who have been using GTM for a while run into tracking issues. Fortunately, most of these problems follow predictable patterns, and you can avoid them if you know where to look.
This article compiles many common GTM mistakes we often see and offers clear, effective solutions. Some are related to GTM itself, while others focus on the connection between GTM and Google Analytics 4 (GA4), which most of us use.
Mistake #1: Working in the wrong container
Have you ever opened GTM and found that Preview mode wasn’t working? Or maybe you tried publishing changes, but nothing really updated on your website. Even after double-checking the configuration, republishing, and clearing your cache, it still didn’t work. Then you realize you’ve been looking at the wrong GTM container the entire time.
This happens more often than you’d think (even to experienced marketers), especially when you manage multiple websites or have access to several client accounts.
The solution?
Before making any changes, always verify you’re in the correct container by checking the container ID. Compare the ID shown at the top of your GTM interface (it looks like GTM-XXXXXX) with the ID in your website’s GTM snippet (you can find it by viewing your page source and searching for “GTM-”).
Additionally, if you frequently work with multiple containers, it’s helpful to use browser bookmarks with descriptive names for each, or keep a simple spreadsheet that maps websites to their container IDs.
Mistake #2: Forgetting to publish after testing
In this scenario, you’ve set up your new conversion tracking tags, tested them thoroughly in Preview mode, and confirmed they fire correctly. The data looks good in GA4’s DebugView, so that’s it, right? Not quite. If you close GTM without clicking Submit, your changes remain in your workspace. They aren’t live on your website, which means you’re only tracking your own test sessions.
The solution?
After testing any changes in Preview mode and verifying in DebugView, always click the Submit button at the top-right corner of GTM and add a descriptive version name so you can identify it later. Make this your standard workflow: build, test, publish, document.
Mistake #3: Skipping Preview and Debug mode
When a tag doesn’t fire, some people immediately start rebuilding triggers or checking variable configurations, but the solution is much simpler: GTM’s Preview and Debug console can tell you exactly why a tag didn’t fire.
The solution?
Instead of guessing, make the Preview and Debug console your primary step when troubleshooting. When you’re in that mode, if you select an event in the left sidebar, the Tags tab shows which tags fired and which didn’t. For tags that didn’t fire, you’ll see red X icons next to the trigger conditions that failed. This is your roadmap for fixing the issue.
Mistake #4: Not removing hardcoded tracking codes
When you decide to migrate tracking to GTM, it’s easy to forget to remove the original hardcoded GA4 tracking code – or maybe you don’t forget about it, but you miss custom event tracking code that developers added for specific interactions. This means that your old tracking code is still on your website, firing alongside your new GTM implementation, so now every page view, every event, and every conversion is being counted twice.
The solution?
Before migrating to GTM, thoroughly audit your website. Open your browser’s DevTools (F12) and check the Network tab to see every tag firing on your pages and look for:
- Hardcoded GA4 base tags (usually in the website header).
- Custom event tracking in JavaScript files.
- Tracking added through CMS plugins or themes.
- Event listeners that fire analytics events directly.
Once you’ve identified everything, systematically remove the hardcoded code after you’ve replicated the same tracking in GTM. Test before and after to ensure nothing breaks and that no double-tracking occurs.
Mistake #5: Not cleaning up your container
If you work with a team or for a company, chances are multiple people have access to your GTM container. So, consider this cumulative scenario: the marketing team added tags for a campaign that ended a year ago; an agency contractor set up tracking for a tool your company no longer uses; a colleague added an analytics tool for a test that was never launched.
Now your container has dozens of tags, but no one knows which are still relevant. Every unnecessary tag adds to your page load time and makes your container harder to manage.
The solution?
Audit your container at least once every six months. Review every tag with your team and remove any that are no longer in use. Assign one person or team as the container owner who approves all changes and maintains documentation.
Mistake #6: Tracking forms with click triggers
Form tracking seems simple: just set up a click trigger on the Submit button, and you’re done. But… this method has a major flaw: click triggers fire whenever someone clicks the button, not when forms are successfully submitted. This means that if a visitor clicks Submit but forgets to fill in a required field, your tag fires anyway. You end up counting failed attempts as conversions.
The solution?
Use GTM’s Form Submission trigger (although it doesn’t support all form types), or collaborate with your developer to push a dataLayer event only on successful submissions. For more complex forms, you might need custom JavaScript that waits for form validation to finish before firing the event – it’s more work, but it ensures your conversion data is accurate.
Mistake #7: Not using naming conventions
You create a tag called “contact”, a trigger named “button2”, and a variable called “click_url_new”. Six months later, someone asks you to audit the container. What does “contact” track? Is it the contact form submission? A click on a contact button? An event when someone views the contact page? You have no idea, and neither does anyone else on your team.
The solution?
Establish clear naming conventions from day one that specify the purpose of each tag, trigger, and variable. Some good examples might be: “tag_form_submit_contact” or “trigger_click_navigation_menu”. Document your naming system in a shared resource and apply it consistently. Your future self and team will appreciate it.
Mistake #8: Publishing everything at once
Imagine you’ve spent a week working on tags for form tracking, scroll tracking, video engagement, e-commerce events, and possibly others. Everything looks good in Preview mode, so you decide to publish the entire batch at once. Then something breaks.
Here’s the problem: when you publish multiple features at once and something goes wrong, you can’t tell which change caused the issue. As a result, you have to revert everything, including the tags that were working fine.
The solution?
Build and test each tracking feature separately, then publish it as its own container version. If you need to roll back, you’ll only affect that specific feature while everything else continues to run. This approach takes a little more time upfront but saves hours of debugging later.
Mistake #9: Missing event parameters in GTM-GA4 integration
You’ve set up your GA4 event tags in GTM and everything fires correctly, but when you start analyzing your data in GA4, you realize you’re missing critical information that would help you understand user behavior.
The problem? GA4 events without parameters provide only basic counts without context. An event called button_click shows how many times buttons were clicked, but not which button, on which page, or what type of content was involved.
The solution?
Include event parameters in your GTM tags from the start. Use dataLayer variables or built-in GTM variables to capture details like button_text, page_location, content_type, or link_url. These parameters make your GA4 events truly useful for analysis instead of just counting events.
Also, remember that GA4 has parameter naming conventions: use lowercase with underscores (button_text, not buttonText or Button Text) and keep names under 40 characters. Plan your parameters before building tags to ensure you capture the right context from the start.
Tip: if you’re adding the same parameters to multiple GA4 event tags, create an Event Settings variable instead of configuring each tag separately. This variable allows you to define parameters once and then add it to all relevant tags. So, when you need to add a new parameter later, you just update one variable instead of searching through dozens of tags.
Mistake #10: Creating multiple triggers instead of using RegEx
If you want to track clicks on several different CTAs across your website, your instinct might be to create separate triggers, one for each button, and assign all of them to the same tag. This approach works, but it’s inefficient – your trigger list gets messy, and if you need to add another button later, you’ll end up creating yet another trigger.
The solution?
Use Regular Expressions (RegEx) – special sequences of characters used to find, extract, replace, or match text – to combine multiple conditions into a single trigger. So, instead of five triggers that each check if the button text equals a specific value, create one trigger with a RegEx pattern that matches all five values at once.
Here’s an example: if you’re tracking CTA buttons with text like “Download now”, “Get started”, or “Try for free”, use a RegEx pattern like Download now|Get started|Try for free. One trigger handles all cases, your container stays cleaner, and adding new values becomes easier.
Final thoughts
Most GTM mistakes follow a similar pattern: rushing through setup without testing, skipping documentation, or not understanding how the pieces fit together. So, naturally, the solution to most of them involves slowing down, testing thoroughly with multiple tools, and documenting changes.
If you want to go even further, check out our “How GTM fits into the GA4 setup” article for specific audit questions you can go through after linking GA4 and GTM.