The container is installed. The Tag Assistant icon in the browser is glowing green. And GA4 is silent. Or showing numbers that have nothing to do with how many leads actually came in this week. It’s a familiar situation for most small and mid-sized business owners in the Czech Republic: you’ve just finished setting up Google Tag Manager for beginners — and decided the job is done.
In reality, it’s only just begun. GTM is an empty box with outlets. Without tags plugged into that box, not a single click, lead, or call reaches GA4, Google Ads, or Meta. Meanwhile, the ad budget keeps getting spent — just without any feedback on what it’s actually delivering.
This article starts from the assumption that the container is already installed: the account setup and installation process itself is outside the scope of this piece. What follows is the next, less obvious stage: which tags to set up first, in what order, and how to make sure each one passes exactly the right data before the container goes live and starts influencing real decisions about ad spend.
Google Tag Manager for Beginners: What GTM Is, in Short
Google Tag Manager isn’t analytics. It’s a middleman that passes commands to other systems: GA4, Google Ads, Meta. It doesn’t analyze anything itself and shows no reports.
The logic inside is simple, even if it looks confusing at first. A trigger defines the moment (“when”). A tag defines the action (“what to do at that moment”). A variable defines the detail (“what exact value to pass”). Example: a visitor clicks the “Request a call” button (trigger) → a GA4 Event tag fires (action) → the button name and page URL are passed along (variables).
Think of it like the electrical wiring in a house: GTM is the fuse box and the wiring, GA4 is the meter and the usage readout. Without the wiring, the meter has nothing to measure, even if the lights technically work.
Closer to daily practice: a visitor fills out and submits a contact form (trigger — Form Submission) → two tags fire at once — a GA4 event and a Meta Lead event (actions) → both receive the phone number or form name, if needed for segmentation (variables). One trigger can fire several tags at once. That’s exactly why setup order matters: the foundation first (GA4), then everything that depends on it.
A question that comes up regularly in search: what’s the actual difference between GTM and Google Analytics, if both work with the same data? GTM doesn’t store or display anything as charts or tables — it only passes commands. You can delete or change a tag in GTM in a minute, without touching the site’s code. Changing how GA4 counts its reports is a separate setting on GA4’s own side.
A full description of all container settings, accounts, and access permissions is available in Google Tag Manager’s official documentation — worth keeping on hand as a reference, even once the container is already live.
1. The GA4 Configuration Tag — the Foundation for Everything Else
GA4 Configuration is the foundation. Without it, no other tag — including Google Ads conversions — will work correctly: they all rely on the session data this tag passes along.
Setting it up: in GTM, add a new tag of type Google Analytics: GA4 Configuration, paste the Measurement ID (format G-XXXXXXXXXX) from the Data Streams section of the GA4 account into the Measurement ID field, and set the trigger to All Pages. This is the one tag that has to “see” every single page on the site, no exceptions.
A typical mistake at this stage is duplication. If the GA4 code was already manually added to the site’s <head> (say, by a developer earlier) and the same tag is also added through GTM, GA4 will count every visit twice. Session counts look twice as high as they really are, and the bounce rate “improves” for no real reason. Checking is simple: open DebugView in GA4, visit the site in another tab, and see whether the same page_view event fires twice within a second.
This is one of the most common reasons data looks inconsistent: traffic seems to be there, but the reports show numbers that don’t add up — and the cause is usually not the ads themselves, but the duplicate.
On WordPress, this happens more often than it seems: the GA4 code might get added by an SEO plugin, the theme, and GTM all at once — each unaware of the others. Before publishing the container, it’s worth opening the page source (Ctrl+U or “View Page Source”) and searching for how many times the Measurement ID appears. More than once — one of the sources should be disabled, and it makes more sense to keep the tag in GTM: it’s easier to manage all tracking from a single, central place.
The Tag Assistant extension (Google’s official Chrome tool) shows the same thing even faster: it highlights in green every tag that fired on the page, making it immediately obvious whether GA4 Configuration fired once — not twice.
2. The Google Ads Conversion Tracking Tag — Without It, the Algorithm Is Flying Blind
A conversion tag with no data is an empty report. If GTM isn’t passing a single conversion, Google’s algorithm is optimizing the campaign blind: it has no idea which auctions and audiences actually lead to leads. This is where ad budget most often goes to waste.
The Conversion ID and Conversion Label come from Goals → Conversions in the Google Ads account, after a conversion action has been created. In GTM, a Google Ads Conversion Tracking tag is added with these two values.
There’s a nuance most basic guides skip: it’s better to attach the trigger not to the form-submit event, but to the thank-you page loading (Thank You Page). A form can technically “submit” at the JavaScript level even when the server returns a validation error or the email never arrives. A trigger on the thank-you page URL (for example, /thank-you) only fires once the lead has actually been processed and the user has seen the confirmation. It looks like a small detail, but it’s exactly what determines whether Google Ads counts real leads as conversions, or just attempts to submit them.
If there’s no separate thank-you page — the form just shows a message on top of the same page — you’ll have to rely on the submit event as a less reliable alternative. In that case, it’s worth at least adding a check that the form actually passed validation (via a variable the CMS or form plugin passes on successful submission), rather than firing on the button click alone.
It’s also worth mentioning Enhanced Conversions separately — a Google Ads feature that lets you pass hashed contact data (email, phone) along with the conversion for more accurate matching against Google accounts. It’s not required for a first launch, but it’s worth keeping in mind at this stage as a logical next step. This becomes especially noticeable as iOS restrictions and third-party cookie blocking cut into standard tracking data — Enhanced Conversions partly compensates for that loss, improving match accuracy even without third-party cookies.
3. The Meta Pixel Tag — and Why the Legal Context Can’t Be Skipped Here
Meta Pixel is needed for two things: retargeting (showing ads to people who’ve already visited the site) and Lookalike Audiences (finding new people similar to existing customers). Without the pixel, neither tool is available.
The basic setup is a Custom HTML tag with the PageView code from Facebook Business Manager, trigger All Pages, plus a separate tag for a Lead event, triggered on form submission or the thank-you page.
This is where it’s important not to skip what most “install GTM from scratch” guides leave out. For visitors from the EU, including the Czech Republic, installing the pixel without visitor consent conflicts with GDPR and ePrivacy Directive requirements around non-essential cookies. Google has already made Consent Mode mandatory for advertisers working with EU audiences: without it, remarketing, audience building, conversion modeling, and enhanced conversions for European traffic are unavailable. The same principle applies to Meta Pixel — the tag should be attached not to the All Pages trigger, but to a trigger that checks the consent category (for example, via GTM’s built-in Additional Consent Checks), and should only fire once the visitor has confirmed marketing cookies in the consent banner.
This isn’t legal advice — the exact wording of terms, areas of responsibility, and the consent banner text should be reviewed with a lawyer before publishing. The principle itself is simple: “the tag waits for consent” instead of “the tag fires immediately.” And it’s a technical detail GTM lets you configure in literally two fields.
One more thing worth keeping in view even at the start: browsers — Safari, Firefox, and increasingly Chrome — are blocking third-party cookies more and more aggressively, the very cookies the pixel traditionally relied on. Data from a browser-only pixel gradually undercounts a portion of conversions, especially on iPhone. The full fix for this — Conversions API, server-side event delivery straight to Meta, bypassing the browser — goes beyond the scope of setting up the first five tags. So “pixel data looks low” shouldn’t be immediately blamed on a trigger mistake: some of that gap is simply normal for the modern web.
If, after this section, you’re still unsure whether the current Meta Pixel and Consent Mode setup on your site already meets these requirements — a free audit of your current analytics setup will settle that faster than working through triggers and consent categories on your own.
4. The Phone and Email Click Tracking Tag
Neither GA4 nor ad platforms see a click on a tel: or mailto: link by default. To the browser, it’s just a regular link that opens the dialer or mail client — and that’s where the story ends for analytics.
The fix: a Just Links trigger combined with a condition that the Click URL contains tel: or mailto:, plus a GA4 Event tag with an event name like phone_click or email_click. The built-in Click URL variable in GTM is enabled under Variables → Configure — without it, the trigger can’t see which link was actually clicked.
For local-service businesses — dental clinics, auto shops, legal consultations — this is often a blind spot in the data. A site’s contact form may bring in fewer leads than it seems, simply because a meaningful share of inquiries are direct calls from a Google Business Profile or the phone number in the site header. Without a dedicated tag, that activity stays invisible.
The tag only captures the click itself, not the call or its outcome. If calls are a primary lead channel for the business rather than a secondary one, the next logical step is a call-tracking service with number swapping: it shows which ad source drove the call and how long it lasted. But that’s a separate system outside GTM. Start with the basic click tag — it’s free and takes a few minutes to set up.
5. The Form Fill Progress Tracking Tag
A form isn’t an all-or-nothing event. Someone starts filling in fields and closes the tab halfway through, and that behavior goes unrecorded if the tag only watches for the final submission.
The basic form tag is Form Submission with the Wait for Tags option: it gives GTM time to send data to GA4 and ad platforms before the browser redirects the user to the thank-you page. Without this option, part of the events get lost simply because the redirect happens too fast. An additional tag — on focus of the first field (say, “Name” or “Phone”) — lets you count how many people started interacting at all, not just how many finished.
For multi-step forms, where contact details aren’t requested on one screen but across several steps (service first, then date, then contact info), it’s worth adding a separate tag for each step rather than just the first field and the final submission. It’s one thing when a visitor didn’t even get to choosing a service, and quite another when they reached the last step and stopped at the phone field.
The gap between those two numbers is form abandonment. A form gets 100 first-field focuses but only 40 completions? That’s not an ads problem and not a traffic problem. It’s a signal that something about the form itself is putting people off: too many fields, a confusing button, a technical error on submit. This is a common pattern for forms with several fields or steps, and it’s the first place to look before suspecting the ads or the traffic. If the problem turns out to be the form itself rather than the tags, the next logical question is why the form on the site isn’t converting: landing page design and optimization fixes that systemically, rather than at the level of a single tag.
How to Verify That All Tags Are Working Correctly Before Publishing
Before publishing the container, three checks are needed: Preview mode in GTM, DebugView in GA4, and reconciling conversion numbers against real leads in the CRM or inbox for the same period.
Preview mode opens the site in a dedicated panel and shows which tags fired on each action: a click, a form submission, a page transition. A tag that should have fired is missing from the list? The problem is in the trigger or firing condition. The panel also shows the order tags fire in over time: if the Google Ads conversion tag appears before GA4 Configuration, that’s a sign of a tag priority problem (Tag Sequencing) — the conversion is technically being sent, but without the foundation it should be relying on.
Preview mode is worth running not just on desktop, but on mobile too — on a phone or through DevTools’ emulation mode in the browser. A significant share of traffic for small and mid-sized businesses in the Czech Republic comes from mobile devices, and some triggers (for example, on a phone-number click in the site header) may be implemented differently on mobile than on desktop — and so may not fire the same way.
DebugView in GA4 is a separate report that shows events in real time with all their parameters. Here you can see not just that something fired, but exactly what was passed: whether the Measurement ID came through, whether page_view got duplicated, whether the right event parameters have values.
The last and most important step — the one missing from most setup guides — is reconciling with reality. Say Google Ads and GA4 show 20 conversions over a week, while the agency’s CRM or inbox shows 15 real leads for the same period? That gap is worth investigating.
A practical benchmark for this kind of gap is 10–15%: if the difference is larger, the cause is usually one of three things — a duplicated tag, a misconfigured trigger (for example, firing on a failed form submission), or lost events from a fast redirect without Wait for Tags. This is an expert estimate based on analytics-setup practice, not an official Google metric.
If these discrepancies aren’t sorted out before publishing, they carry forward: into reports, into decisions about scaling campaigns, into next month’s budget. Self-managed setups most often break down right here — not in installing GTM itself, but in this last verification step, which is easy to skip once the container is already “green” and looks ready.
If the numbers still don’t add up after checking, or there’s no time to dig through triggers and Consent Mode — a free audit of your current analytics setup will find where the data is actually leaking faster than manually going through the tags.
What’s Next
These five tags aren’t the whole possible set — they’re the minimum without which any conversation about ad effectiveness stays a guessing game. None of them is technically difficult on its own — each takes five to fifteen minutes to set up. The difficulty isn’t the number of clicks in GTM, it’s the details that are easy to miss: duplicated GA4 code, a trigger on the form instead of the thank-you page, a pixel with no consent binding, a form without Wait for Tags. Each detail looks minor on its own — but together they create the gap between what the ad dashboards show and what’s actually happening with the business.
What logically follows is enhanced e-commerce tracking, attribution models, and full reporting — but that’s the next level, once the base data has already been verified and can be trusted.
Once the tags are set up and the data is confirmed, the next logical question is whether the budget is being spent efficiently on the campaigns themselves. That’s where PPC campaign optimization comes in: without correct tracking, optimizing auctions and bids is like driving a car with the speedometer taped over.
If reading this left you with the sense that some of these five tags in your own container aren’t set up quite the way described above — that’s normal. And that’s exactly the moment to request a consultation and get a concrete list of what’s worth fixing first.
