A GTM container you can hand to somebody else
Most containers we open have forty tags, a dozen of which fire on something nobody can explain and four of which duplicate each other. The container is not the problem — the missing dataLayer specification underneath it is. We define what the site pushes and when, build the container on top of that, name everything so the next person can read it, and remove what is not doing anything.
Free30 minutesNo obligation
GTM implementation · what breaks
Why containers end up like this — GTM implementation
- 01
Tags nobody can explain and nobody dares delete
Added by an agency three years ago for a campaign that ended. They still fire on every page and still cost load time.
- 02
Tracking that breaks whenever the site changes
Because triggers are built on CSS selectors and page paths rather than on a dataLayer the developers maintain deliberately.
- 03
The same conversion firing from two tags
Nobody noticed because both look correct in isolation, and the doubled number looked like a good month.
- 04
A container only one person understands
And that person has left. Every change becomes an investigation.
GTM implementation · the fix
What you get out of it — GTM implementation
A documented dataLayer specification
What gets pushed, when, and with what structure — a contract between the site and the container.
Triggers that survive a redesign
Built on dataLayer events rather than on selectors that break when someone changes a class name.
A container that reads cleanly
Consistent naming, no orphans, no duplicates, and every tag traceable to a reason.
Faster pages
Removing what is not needed is usually the single largest performance win available in a container.
GTM implementation · architecture
Why the numbers were wrong before you got here — GTM implementation
Worth understanding before buying anything, because it decides which tier you need — and for some readers the answer is that you don't need us yet.
- 1
The browser is the weakest link, and it is getting weaker on purpose
Every browser-side tag has to survive the page loading, the visitor staying, the script running and the request leaving. All four are now contested. The order in your database is certain; the browser event reporting it is not.
- 2
Safari caps the cookie your attribution depends on
Intelligent Tracking Prevention limits JavaScript-set cookies to seven days whatever expiry you set, so a customer who takes longer than a week to decide returns as a stranger. A cookie your own server writes in an HTTP response is not capped — the single largest practical difference between browser-side and first-party server-side.
- 3
Ad blockers remove the tag with no error
A blocked pixel does not warn anyone. The customer buys, the order lands, and no platform hears about it. First-party events from your own subdomain are not a third-party request and are not filtered the same way.
- 4
Consent is enforced by hope, not by architecture
Client-side consent means trusting each vendor script to honour a flag. A server container decides at the container: a denied destination receives nothing. That is a materially stronger position, and it also stops the over-blocking that discards data no law required losing.
- 5
Checkout can end where your tag isn't
Wallets and hosted payment pages can be abandoned after the money moves. Sending the purchase from the order record means it arrives whether or not anyone came back.
GTM implementation · diagnose
How we scope gtm implementation
Before quoting. Each step narrows what the work actually is, so the price reflects your account rather than an average.
- 01
Included: container audit
Every tag classified with a documented reason.
- 02
Included: dataLayer specification
Agreed with your developers before implementation.
- 03
Included: full container rebuild
Tags, triggers, variables, consent gating, naming convention.
- 04
Included: handover
Documentation and a recorded walkthrough.
- 05
Not included: dataLayer implementation on your site
We specify it; your developers implement it, or we quote that separately. Being explicit about this avoids the most common project delay.
- 06
Not included: server-side container
That is the server-side engagement. A clean web container is a prerequisite for it, not a substitute.
- 07
Not included: third-party tags we cannot verify
We will install them and say plainly that we cannot vouch for what they do.
- 08
Not included: ongoing container management
We build and hand over. A retainer is a separate conversation.
GTM implementation · prove
How the work gets proven — GTM implementation
A dashboard turning green proves a dashboard turned green. These are what we hand over instead.
Source of truth
What the browser actually sends, read from the network, compared against your backend records
- Every tag in the finished container traceable to a documented purpose.
- A real conversion followed through the container with exactly one tag firing per destination.
- The dataLayer specification confirmed against what the site pushes on a live journey.
- Page weight and request count before and after the cleanup.
- Reconciled over a fully closed window, matched on ID rather than on totals — totals hide equal and opposite errors.
- Payload evidence captured from real transactions, saved to your own records.
- The same reconciliation repeated 30 days later, because a setup that works once and drifts is the harder failure.
GTM implementation · free audit
What we check in the free audit
- Included: container audit
- Included: dataLayer specification
- Included: full container rebuild
- Included: handover
- Not included: dataLayer implementation on your site
- Not included: server-side container
Checked against
What the browser actually sends, read from the network, compared against your backend records
Free30 minutesNo obligation
GTM implementation · when not to buy
When you shouldn't buy this — GTM implementation
We would rather say it now than three weeks into an engagement.
- If your container is small, understood, and working, leave it alone. Tidiness is not a business outcome.
- If your real problem is that conversions are inaccurate rather than that the container is messy, the server-side build is the project — a clean container sending the wrong events is still sending the wrong events.
- If you have no developer resource to implement a dataLayer, we should talk about that constraint before you commission this. It is the usual reason these projects stall.
- If you are on a platform with a good native integration and few custom needs, GTM may be more machinery than you need.
GTM implementation · what we deliver
What's included in gtm implementation
dataLayer specification
Written and agreed with your developers before anything is built, because the container can only be as reliable as what the site pushes into it.
Container audit and cleanup
Every existing tag classified — keep, fix, remove — with the reason recorded so nothing is deleted on a hunch.
Rebuilt tags, triggers and variables
Named to a convention, with the convention documented.
Consent Mode v2 and consent gating
Wired to your banner, with defaults before load, and each tag's consent requirement set deliberately.
Version control and publishing discipline
Named versions with change notes, and a workspace convention, so a bad change can be identified and rolled back.
Handover documentation and a walkthrough
Recorded, so your team can maintain it without calling us.
Written guarantee
95%+ tracking accuracy
Measured against What the browser actually sends, read from the network, compared against your backend records. Miss it and we keep working at no cost.
Pricing
Pick the package that fits your ad spend
Browser-side starter
$400One-time fee · lifetime ownership
The correct browser-side build, done properly and verified on a live transaction. Honest about its ceiling: it will not survive Safari's cookie cap, an ad blocker, or a checkout that ends somewhere your tag isn't. If you spend $1K+/month on paid media, start one tier up.
- Correct events, correct parameters, correct values
- Verified on a live transaction, not in preview
- Reconciled against your own order records
- Written handover you keep
1st-party server-side
Recommended$800One-time fee · most popular
The tier that changes the outcome rather than patching it. Your money events stop depending on the browser: they are sent from your order records through a first-party server container on your own subdomain, so iOS, ad blockers, consent banners and interrupted payment redirects can no longer take them away. Built in 2–4 days. You own the stack outright, with no monthly SaaS.
- First-party server container on your own subdomain
- Money events sent from your order records, not the browser
- Meta, Google, TikTok, Microsoft and LinkedIn all fed server-side
- Deduplicated on a shared event ID, verified at every destination
- First-party cookies beyond Safari's 7-day cap on JavaScript-set cookies
- 95%+ conversion accuracy and 8+ Meta EMQ, guaranteed in writing
Full 1st-party stack
$1,800One-time fee · lifetime ownership
Every paid-media channel server-side, plus the offline loop that connects closed revenue back to the click. For advertisers whose spend makes an attribution leak more expensive than the build.
- Everything in 1st-party server-side
- Pinterest, Snapchat, Reddit and LinkedIn CAPI
- CRM and offline conversion loop, so closed revenue reaches bidding
- Refunds and cancellations reversed at every destination
- Klaviyo identity stitching, BigQuery and Looker Studio
- Monitoring, so the next break surfaces in days rather than a quarter
FAQ
GTM implementation questions, answered
Because everything else depends on it. A trigger built on a CSS selector breaks silently the next time someone changes a class name, and you find out weeks later when a number looks wrong. A trigger built on a dataLayer event breaks only when a developer deliberately changes the event, which is a conversation rather than an accident.
Almost always, and it is usually the better option — a rebuild in a new container means re-pointing everything and losing the version history. We rebuild in place, in a workspace, so you can review before anything publishes.
That is exactly why every tag gets classified with a reason before anything is deleted, and why we publish a named version that can be rolled back in one click. If we cannot establish what a tag does, we say so and leave the decision with you rather than deleting it quietly.
Not necessarily. If your site is simple and your platform has solid native integrations, GTM can be more moving parts than value. It earns its place when you have multiple destinations, custom events, consent requirements, or a need to change tracking without a deployment.
Free · 30 min
Get a container the next person can read
WhatsAppFree30 minutesNo obligation
