I've been in digital marketing for over 20 years. I've watched Google Tag Manager go from "the tool that will finally free marketers from developer dependencies" to becoming yet another tool that... requires developers.
The promise was simple: marketers could manage their own tracking. The reality? Most can't. And it's not because they're not trying hard enough.
The Setup: What GTM Actually Requires
Let me start with what seems like a simple task: tracking clicks on a "Request Demo" button.
In GTM, you need to:
- Create a trigger that identifies the button
- Choose between Click ID, Click Classes, Click Text, Click URL, or CSS Selector
- Test in Preview mode to see if it fires
- Debug why it didn't fire (wrong selector? wrong trigger type?)
- Try a different approach
- Test again
- Maybe it works this time
For someone with technical background, this is annoying but doable. For most marketers, it's a minefield of trial and error.
The documentation assumes you understand CSS selectors. The tutorials expect you to know what nth-child(3) means. The community forums are full of regex patterns and JavaScript debugging tips.
This is a tool built by engineers, for engineers.
The Three Walls
Most marketers hit three distinct walls with GTM. Each one progressively harder to climb.
Wall #1: CSS Selectors (Maybe 40% Get Past This)
Even "simple" click tracking requires understanding CSS selectors.
You need to know:
- What classes and IDs are
- When to use
#vs. - How to handle elements without IDs or classes
- What
:nth-child()means - When to use descendant vs child selectors
For a marketer trying to track a button, seeing div.container > button.cta:nth-child(2) might as well be hieroglyphics.
Some marketers power through this. They watch tutorials. They test for hours. They eventually figure out basic click tracking.
Maybe 40% make it past this wall.
Wall #2: GTM's Interface Complexity (Maybe 20% Get Past This)
GTM gives you a dozen ways to accomplish the same task. This flexibility is the problem.
For click tracking alone, you can use:
- Click - All Elements trigger with Click ID
- Click - All Elements trigger with Click Classes
- Click - All Elements trigger with Click Text
- Click - All Elements trigger with Click URL
- Click - Just Links trigger
- Custom Event trigger
- Element Visibility trigger
Each method might work. Or might not. You won't know until you test. And testing means:
- Publishing to a GTM container
- Loading Preview mode
- Clicking around your site
- Checking the debug console
- Seeing it didn't fire
- Trying a different approach
- Repeat
The marketers who made it past Wall #1 now face decision paralysis. Which trigger type? Which variable? Which approach?
Many give up here. Some persist and eventually figure out a method that works for basic tracking.
Maybe 20% make it past this wall.
Wall #3: The JavaScript Wall (Maybe 5% Get Past This)
Then come the tracking requirements that actually matter for most businesses:
AJAX Form Tracking
Your contact form submits without a page reload. You want to track form submissions in GA4.
The technical reality:
- GTM can't natively intercept AJAX/Fetch requests
- You need custom JavaScript that:
- Intercepts the XHR/Fetch request
- Captures the response
- Parses the data
- Formats it correctly
- Pushes it to the data layer
Here's what that code looks like:
<script>
(function() {
var originalFetch = window.fetch;
window.fetch = function() {
return originalFetch.apply(this, arguments).then(function(response) {
var clonedResponse = response.clone();
clonedResponse.text().then(function(text) {
if (response.url.includes('/api/contact')) {
try {
var data = JSON.parse(text);
if (data.success) {
window.dataLayer = window.dataLayer || [];
window.dataLayer.push({
'event': 'form_submission',
'form_name': 'contact',
'form_status': 'success'
});
}
} catch(e) {}
}
});
return response;
});
};
})();
</script>
This isn't "advanced GTM." This is software development.
eCommerce Data Layer Implementation
You want to track add_to_cart, purchase, and view_item events with proper GA4 formatting.
The technical reality:
- You need JavaScript that creates event listeners on buttons/forms you don't control
- Scrapes product data from the DOM (name, price, ID, category)
- Formats it into GA4's eCommerce schema (items arrays, transaction IDs, currency codes)
- Pushes it to the data layer
- All through GTM, without touching website code
Here's a simplified version of what's required:
<script>
document.addEventListener('click', function(e) {
if (e.target.matches('.add-to-cart-button')) {
var productCard = e.target.closest('.product-card');
var productData = {
'event': 'add_to_cart',
'ecommerce': {
'currency': 'USD',
'value': parseFloat(productCard.querySelector('.price').textContent.replace('$', '')),
'items': [{
'item_id': productCard.dataset.productId,
'item_name': productCard.querySelector('.product-name').textContent,
'price': parseFloat(productCard.querySelector('.price').textContent.replace('$', '')),
'quantity': 1
}]
}
};
window.dataLayer = window.dataLayer || [];
window.dataLayer.push(productData);
}
});
</script>
And that's the simple version. Real implementations handle:
- Multiple button types
- Different DOM structures
- Quantity selectors
- Variant selection
- Error handling
- Cross-browser compatibility
Maybe 5% of marketers can write this code. And that's being generous.
The Developer Dependency Problem
So what happens when 95% of marketers hit the JavaScript wall?
Option 1: Hire a Developer
If you're agency-side or freelance:
- Budget conversation with client
- Project scoping
- Billing for something that "should be simple"
- Wait time
- Back-and-forth on requirements
- Testing cycles
- Final delivery
Cost: $500-$2000 per implementation Time: 1-3 weeks
Option 2: Submit a Ticket and Wait
If you're in-house:
- Submit ticket to dev team
- Wait for prioritization
- Get assigned a developer
- Try to explain what you need
- Developer explains what's technically possible
- Somehow you're speaking different languages
- Compromise on implementation
- Wait for testing
- Wait for deployment
Time: 2-6 weeks (if you're lucky) Result: Implementation that "mostly" works
Option 3: Give Up
Many marketers just... stop tracking certain things.
No AJAX form tracking. No detailed eCommerce events. Just the basics: pageviews and whatever click tracking they could figure out.
This means:
- Incomplete analytics
- Poor attribution modeling
- Weak conversion optimization
- Decisions based on partial data
Why This Matters
Google Tag Manager was supposed to democratize tracking. Instead, it created a new technical bottleneck.
The marketers who can code become invaluable. The ones who can't become dependent. And the ones who could learn given better tools never get the chance.
The 90% problem isn't about intelligence or effort. It's about a tool that requires software development skills for anything beyond basic tracking.
And that's a solvable problem.
What I Built
After spending years hitting these same walls on client projects, I built TagCompanion - a JavaScript code generator for GTM.
The core insight: stop making marketers write code or understand GTM's complexity. Just let them point and click.
For CSS Selectors: An SDK that lets you click any element on your actual website. It generates the perfect CSS selector automatically, handles nth-child complexity, and eliminates the guessing game of which GTM trigger to use.
For AJAX Tracking: Point-and-click configuration that generates the JavaScript interception code. You select the form, test the response, pick which data you want. It writes the Custom HTML tag code for you.
For eCommerce: Point-and-click configuration that generates all the event listener JavaScript, DOM scraping logic, and GA4 formatting. You identify the product card structure once, it generates the code.
Everything outputs as a GTM container file. Import it, publish it, done. No website code changes needed.
It's focused on static websites and traditional architectures because that's what 95% of marketers are actually working with. If you're running a complex SPA, you probably have the dev resources to handle GTM directly.
The Mission
I didn't build this to disrupt an industry or chase a market opportunity.
I built it because I was tired of:
- Spending hours debugging CSS selectors
- Waiting weeks for developers to implement tracking
- Watching marketers compromise on their analytics because the tooling failed them
GTM is powerful. But power without accessibility is just gatekeeping.
The 90% shouldn't have to learn JavaScript to track a form submission.
TagCompanion is available at tagcompanion.com with a free tier for basic tracking needs. I'm actively looking for feedback on technical implementation and edge cases I haven't considered.
