The story of how 20+ years of marketing experience and countless hours of GTM frustration led to a better way.
Tag Companion was born out of frustration: the kind that builds up over years of doing the same thing the hard way, over and over again.
I've been in digital marketing for more than 20 years. I've seen tools come and go, platforms rise and fall, and countless "solutions" that promised to make our jobs easier. When Google Tag Manager launched, it seemed like one of those promises. Finally, marketers could manage their own tracking without constantly bothering developers.
Except that's not what happened.
What we got was a powerful tool built by engineers, taught by engineers, and documented for engineers. The tutorials assumed you understood CSS selectors. The guides expected you to know what a data layer was. The community discussions were full of regex patterns and JavaScript debugging tips.
For someone with technical curiosity and time to spare, I could eventually figure things out. But "eventually" meant hours of trial and error. It meant watching the same tutorial three times. It meant testing selectors in GTM Preview mode, hoping this time the event would fire.
And I was one of the lucky ones. I at least had some technical foundation to work from.
For most marketers, GTM remained what it had always been: a developer tool.
When you couldn't figure it out yourself, you had two options:
If you were working with a client, you could hire a developer. That meant budget conversations, project scoping, and billing for something that should've taken five minutes.
If you worked in-house, you could submit a ticket and wait. Days would pass. The ticket would get reassigned. Eventually, you'd get on a call where you tried to explain what you needed, and the developer tried to explain what was technically possible, and somehow you were both speaking different languages.
I've had conversations where I knew exactly what I wanted to track, but couldn't articulate it in a way that made sense technically. And I've had developers explain their implementation in terms I couldn't parse, so I'd just nod and hope it worked.
Even when it worked, it often came with compromises. An event that mostly tracked what you needed. A selector that usually caught the right element. Close enough.
But even when you figured out basic click tracking, there were two massive walls most marketers could never climb:
Contact forms that submit without page reload. Login overlays. Search boxes that show results instantly.
The technical reality: You need custom JavaScript to intercept the XHR/Fetch request, capture the response, format it, and push it to the data layer. That's not "advanced GTM." That's software development.
Tracking add_to_cart, purchase, view_item events with proper GA4 formatting.
The technical reality: You need custom JavaScript that creates event listeners on buttons/forms you don't control, scrapes product data from the DOM, formats it into GA4's eCommerce schema (items arrays, transaction IDs, currency codes), and pushes it to the data layer. All through GTM. Without touching the website code.
Most marketers I know have heard these terms. Maybe even sat through a presentation. But implementing them? That requires writing JavaScript. That's why 90% of marketers are stuck waiting for developers.
About a year ago, I started thinking: what if we just... simplified the GTM interface?
GTM gives you a hundred options. Built-in variables. Trigger types. Variable types. Click ID, Click Classes, Click Text, Click URL. You can track clicks a dozen different ways, and each one might work or might not. The flexibility is the problem.
What if we just standardized on one reliable approach and eliminated the guessing?
Use CSS selectors. They're solid. They're reliable. They work for 95% of marketing websites. Stop making marketers choose between a dozen GTM options and spend hours testing which one fires. Just give them one method that works.
We have built an SDK that lets you point and click on your actual website. It generates the perfect CSS selector. It handles nth-child complexity automatically. No more guessing whether to use Click ID or Click Classes. No more testing in preview mode for two hours.
One interface. One method. CSS selectors for clicks and visibility tracking.
CSS selectors solved clicks and visibility. But that was only part of the problem.
AJAX forms and eCommerce tracking still required writing custom JavaScript. For years, I had an old AJAX tracking script I kept reusing: copying it, pasting it into GTM, manually tweaking the selectors and data layer paths for each project. It worked, but it was tedious. Every new form meant 20 minutes of code editing.
Then it hit me:
What if I could automate this? What if instead of manually editing the script each time, I could build a tool that generates the JavaScript dynamically based on what the user selects?
I built it. You select the form. You test the AJAX response and pick which data you want. The tool writes the JavaScript: the interception code, the data layer push, the entire Custom HTML tag. Ready to import into GTM.
It worked. That was the first "holy shit" moment.
Then came the second insight: If I could automate AJAX JavaScript generation, why not apply the same approach to eCommerce data layers?
eCommerce tracking is even more complex: event listeners on buttons you don't control, scraping product data from the DOM, formatting it into GA4's schema, pushing it to the data layer. All through GTM, without touching the website code.
I built the automation. Point-and-click configuration that generates all the JavaScript. It worked.
Tag Companion is a JavaScript code generator that works through point-and-click interfaces. You select what you want to track. It writes the code. You import it into GTM.
Click any element. SDK generates perfect selectors, handles nth-child complexity. No guessing GTM variables.
Generates custom JS that intercepts XHR/Fetch, captures responses, pushes to data layer. Works through GTM.
Generates custom JS for event listeners, DOM scraping, GA4 formatting. No website code changes.
How it works:
Everything runs through GTM. No website code changes. No developer access needed. The JavaScript is injected via GTM Custom HTML tags and runs on your site through Tag Manager.
We focused on static websites and traditional architectures because that's what 95% of marketers are actually working with. If you're running a complex Single Page Application, you probably have the dev resources to handle GTM directly. Tag Companion is for everyone else.
I didn't build Tag Companion to disrupt an industry or chase a market opportunity.
Tag Companion doesn't just make GTM easier.
It makes things possible that were previously impossible without a developer.
It's not perfect. It doesn't solve every edge case. But for the core tracking needs of most marketing websites (clicks, AJAX forms, eCommerce events), it turns impossible into possible, and hours into minutes.
You point and click.
Tag Companion writes the JavaScript.
That's the mission. That's the product.
That's Tag Companion.
Join the marketers who've reclaimed their time and sanity.