Which of your campaigns actually produce sign-ups?

If the honest answer involves guesswork, a spreadsheet of leads with no source column, or a ticket to whoever owns the website, you are where most marketing teams sit. Raw reports tell you how many visits and clicks happened, but they stay quiet on which ad, which search term or which newsletter sent the person who filled in the form. GA4 conversion tracking fixes that silence by measuring the actions your business cares about, such as form submissions, demo requests and sign-ups, and giving them a consistent definition across every report (Google's introduction to key events).

Google Tag Manager, usually shortened to GTM, is the free layer that lets you wire those events without touching the site's code (Google's introduction to Tag Manager). This guide walks the whole path for a typical service business with a demo-request form: the one-time container install, an event that fires when the form succeeds, the test that proves it works, and the import that lets Google Ads measure the same definition of a good outcome. By the end you will be able to open one report and see which campaigns produced actual sign-ups.

Key events, tags and triggers: the pieces in plain language

Four terms carry the whole setup, so they are worth pinning down before any clicking. An event is any interaction GA4 can record, and each event has a name (Google's reference on events). A key event is an event your business treats as important: the action you would build a report or an ad bid around. Google renamed what Analytics used to call conversions to key events, and the word conversion now refers to that same action seen from the Google Ads side (Google's explanation of conversions versus key events).

A container is the Tag Manager project for your website, and it holds every tag and trigger you create. Tags are the instructions: a GA4 event tag says, send an event with this name to that property (Google's walkthrough for GA4 event tags in Tag Manager). Triggers are the conditions: a Form Submission trigger says, fire the tag when a form has been sent (the Form Submission trigger reference). The container snippet installs once in the site, and every change after that happens in the GTM web interface, which is why this whole setup survives without a developer (Google's guide to creating an account and container).

The visitor submits the form. Tag Manager hears it and fires the event tag. GA4 records a key event. Google Ads counts a conversion.

Each piece keeps its own job, which is why you can change any of them later without a developer: rename an event, fire on a different form, import to a new Ads account. The sections that follow build that chain in order, and each one ends with a way to check it actually works.

The accounts and access you need before the first tag

Run through the prerequisites once and the rest of this guide takes an afternoon. A data stream is the pipe that carries events from your website into a GA4 property, and its measurement ID, a code that starts with G-, is the address your tags send to (Google's GA4 website setup walkthrough).

Access here simply means who can click in each account. If the property or container belongs to an agency or a former employee, ask the account owner to add you as an Editor, because nothing in this guide needs Administrator rights.

Cost is the easy part. GA4, Google Tag Manager and Tag Assistant are free Google products, and while Google Ads itself is paid, importing conversions from Analytics adds nothing to the bill.

Connect Tag Manager to GA4 with the Google tag

The Google tag is the tag type that loads GA4 on the page, sets the cookies GA4 needs and collects the automatically tracked events (Google's guide to setting up GA4 in Tag Manager). If GA4 is not running on the site yet, this step switches it on through GTM.

  1. Open your container in Tag Manager and go to Tags. Click New, name the tag GA4 Google tag, and open Tag configuration. Choose Google tag, then paste the measurement ID from your GA4 data stream. On older containers this tag type may appear under its previous name, Google Analytics: GA4 Configuration. The ID lives in GA4 under Admin, Data streams, your web stream, and looks like G-XXXXXXXX.
  2. Under Triggering, choose All Pages and save the tag. Open Preview mode next, because Tag Assistant opens a debugging session that shows whether the tag fires on your site before anything goes live (Google Tag Assistant).
  3. Submit the container and publish it, since nothing reaches GA4 until a container version is live. GTM asks for a version name, so call it something readable like GA4 Google tag, and later versions stay easy to tell apart.

One caution if GA4 already runs through a snippet in the site code: adding the Google tag here as well would load the property twice and double every hit. Keep the loader you already have and skip this section, because the event tags that follow send straight to the same measurement ID, and GTM still becomes the home for the conversion events.

Create the key event: an event tag that fires when a form succeeds

A form that reloads or redirects after submit is the easy case, and it is the one GTM's Form Submission trigger handles natively. Start with that setup, because it covers most marketing sites, then read the notes below for forms that never reload. Google recommends generate_lead as the event name for sign-ups and lead forms, because prebuilt GA4 features recognise it without extra configuration (Google's tutorial on setting up a key event). A demo request is a lead by any definition, so the tag below sends generate_lead.

  1. Enable the form variables. In GTM, go to Variables, click Configure, and tick Form ID and Form Classes. These are the built-in variables the trigger needs to tell one form from another (Google's Form Submission trigger reference).
  2. Create the trigger. Go to Triggers, click New, and choose Form Submission as the trigger type. Switch on Wait for Tags so the page does not finish submitting before the tag fires, and switch on Check Validation so the trigger only fires on a submission the form accepts (Google's notes on the Form Submission options).
  3. Scope the trigger with Some Forms. A condition such as Page URL contains /contact or Form ID equals the value from Preview stops the event firing on the search box and the newsletter signup. To find the ID, open Preview mode, submit the form once, and read the Form ID variable in the left panel (Ryker Analytics' no-developer form tracking guide).
  4. Create the event tag. Go to Tags, click New, and under Tag configuration choose Google Analytics: GA4 Event. Enter the same measurement ID, set Event name to generate_lead, and attach the trigger you just made (Google's walkthrough for GA4 event tags).

Forms that never reload need a different trigger moment

The Form Submission trigger listens for the browser's native submit, and modern embedded forms often send data in the background and skip that event entirely (Tech Buba's beginner GA4 event tracking tutorial). Two no-developer patterns cover those forms. The first watches for the success message: after the form succeeds the page shows a thank-you line, and an Element Visibility trigger on that line fires the same event tag (Amplio Data's guide to form tracking in GA4 with GTM). The second uses the thank-you page: if the form redirects to something like /thank-you, a Page View trigger filtered to that URL fires generate_lead, and many teams prefer it because the page load is the cleanest proof the submission finished (Ryker Analytics' comparison of the two methods). A practical summary of when each method works lives in AdConversion's form tracking guide (AdConversion's form submission tracking comparison).

There is also a route that skips GTM altogether: GA4 can build a new event from an existing one, for example a page_view on the thank-you page, and you mark that new event as the key event (Google's guide to creating events from existing ones). It suits a single form. Once several forms or ad accounts are involved, GTM earns its keep because everything lives in one container.

Whichever pattern you choose, keep one signal per submission. If GA4's enhanced measurement has form interactions switched on in the data stream, it already sends its own form events for standard forms, so either turn that toggle off or accept two records for the same action (Google's enhanced measurement reference).

Publish the container and test the event on the live site

A setup that has never fired is a guess, so the test happens before you call this done. The sequence below checks the tag fires, the event arrives, and the key event records on the real site.

  1. Preview the container. In GTM, click Preview, and Tag Assistant opens a debugging session on your site (Google Tag Assistant). Submit the form with test values and watch the GA4 Event tag appear under Tags Fired. A green tag here proves the tag fired, not that GA4 received the event, so keep going before you trust it (Amplio Data's warning about preview mode).
  2. Confirm the event in GA4 DebugView. In GA4, go to Admin, Data display, DebugView, and repeat the submission. generate_lead should appear in the stream within seconds, because DebugView shows events from one device in real time during a debug session (Google's DebugView reference).
  3. Publish the version. Back in GTM, click Submit, name the version and publish it, since only your debug session has seen the tag until this point.
  4. Prove it on the real site. Open GA4 Reports, Realtime, and submit the form again in a normal browser window. The Key events by event name card should list generate_lead within a minute (Google's Realtime report reference). Realtime shows the last 30 minutes of activity, so it is the fastest proof available; standard reports take 24 to 48 hours to process (Google's notes on report processing times).

One honest note for EU and UK audiences: consent mode changes what GA4 measures before someone accepts cookies, and it is configured separately from the tags in this guide, so check Google's current consent mode documentation before you publish. If you want to practise any of this without touching real data, Google's demo account includes a sample store with its own property to click around in (Google's GA4 demo account).

Mark key events as conversions and import them into Google Ads

A key event in GA4 does not automatically become a Google Ads conversion. The import step tells Ads to treat generate_lead as a conversion for reporting and bidding, and only events marked as key events are eligible for it (Google Ads Help on importing Analytics conversions).

  1. Mark the key event. In GA4, go to Admin, Data display, Events, open the Key events tab, and click the star next to generate_lead (Google's guide to marking events as key events). GA4 marks purchase and first_open as key events by default; every other event only earns the star when you add it.
  2. Link the accounts once. In GA4, go to Admin, Product links, Google Ads links, and add your Ads account. This needs Editor access on the property and Admin access in Ads, and it switches on auto-tagging as part of the link. Data flows both ways after that, and Ads activity appears in Analytics reports within 48 hours (Google's guide to linking Google Ads to Analytics).
  3. Create the conversion. In GA4, go to Advertising, and under Tools open Conversion management (Google's guide to creating conversions from Analytics events). Pick the Ads account, click New conversion, choose generate_lead, click Select events, and save. At least Marketer access on the property is required (Google's conversion management instructions). After linking or marking an event, import options can take 24 to 48 hours to appear, and conversion data up to 24 hours after that (Google Ads Help on setting up web conversions).

Conversions created from Analytics key events are shared between the products, so GA4 and Google Ads report the same base numbers, and Google Ads sets them as secondary when the account already has goals from an Analytics property, which stops the same action counting twice for bidding (Google Ads Help on conversions created from GA4 key events).

Google's own analysis correlates linking Ads or Google Marketing Platform accounts to a GA4 property with a 23 percent increase in conversions and a 10 percent reduction in cost per conversion (Google's note on what changes when accounts are linked). That comes with the usual correlation warning: linking does not cause the improvement by itself. It is the prerequisite for every conversion-driven decision that follows, which is why the wiring matters more than the star icon.

The reports you can trust once GA4 conversion tracking is live

With the star and the import in place, GA4 conversion tracking starts answering the question this guide opened with. In Google Ads, the campaign report now carries a Conversions column fed by the same key event you marked, so the campaign with the best cost per sign-up stops being a guess.

In GA4, marking the event as a key event also switches on the analytics that surround it: the paths people take before submitting, the key event rate for each source, and remarketing audiences of people who submitted or did not (Google's guide to measuring form submissions as key events). Those reports tell you whether the traffic quality or the page itself is what needs work.

Two timing notes keep the numbers honest. Standard GA4 reports and explorations process data on a 24 to 48 hour lag, so let a week of data settle before judging a campaign (Google's notes on report processing times). And only events marked as key events stay eligible for the Ads import, so when a new form appears on the site, the routine is the same three steps: fire the event, star it, import it (Google Ads Help on web conversion eligibility).

Once sign-ups carry source data, they can feed the next stage of the funnel. Our guide to lead scoring with Google Analytics and Salesforce shows how to rank those leads without a data team, and the spend-to-pipeline view in our marketing budget attribution guide builds on the same clean event stream.

Frequently asked questions

Do I need a developer for any part of this setup?

One small exception: the Tag Manager container snippet has to live on the site once, which means pasting two lines into the page template or into a plugin field, so whoever controls the website does that part. Everything after it, the Google tag, the event tag, the trigger, the key event and the Ads import, happens with clicks in Google's admin panels. GA4, Tag Manager and Tag Assistant are free Google products, and importing conversions into Google Ads adds nothing to the Ads bill.

The form submitted but no event fired. What should I check first?

Check the trigger scope first, then prove the event arrived. The Form Submission trigger only catches a native browser submit, so many modern forms, which send data in the background and never reload the page, keep it silent. In GTM Preview, confirm the tag appears under Tags Fired, then open GA4 DebugView and repeat the submission, because a green preview tag does not prove GA4 received the event. If the form stays on the page, switch to a success-message or thank-you page trigger, and make sure enhanced measurement is not sending a second signal for the same submission.

Will the same conversion be counted twice now that GA4 and Google Ads are linked?

No, on the Ads side. Conversions created from Analytics key events are shared between the two products so both show the same numbers, and Google Ads sets them as secondary when the account already has goals from an Analytics property, which stops the same action counting twice for bidding. Inside GA4, keep one signal per submission: either enhanced measurement or your Tag Manager tag, not both.

Why do the numbers in Google Ads and GA4 not match exactly?

A few reasons, all normal. Imported conversion data can take up to 24 hours to appear in Ads, import options up to 48 hours after linking, and standard Analytics reports run on a 24 to 48 hour processing lag, so the two products rarely agree on the same day. Where Google cannot observe every step of a journey, Ads may also report modelled conversions alongside observed ones. The counts come from the same key events once the import is live, so the gap narrows as the data settles.

How do I tell the demo form apart from the newsletter form in reports?

Scope the trigger so each form sends its own event. Use Some Forms with a condition such as the page URL or the form ID, and find that ID in GTM Preview, where the form variables appear in the left panel after a submission. With one trigger per form, the contact form and the newsletter signup never share an event, and the key event counts only what you scoped it to.

How long does the whole setup take?

The container install is the only step that depends on someone else, and it happens once. From there, the rest of this guide, the Google tag, one event, the live test, the key event and the Ads import, fits in an afternoon of clicking. If you would rather spend that afternoon on campaigns, a Supernodes pilot can have the measurement foundation live in two weeks: an audit of what you already track, key events for the forms that matter, and the Google Ads import.

Wire your own conversion tracking this week

The whole setup collapses into four actions, and each one has a check attached so nothing ships on faith.

  1. Confirm the accounts and access from the prerequisites list, including the one-time container snippet install.
  2. Load GA4 through the Google tag, or confirm the existing loader, and publish the first container version.
  3. Pick one form, fire generate_lead on a successful submit, and prove the event appears in the Realtime report.
  4. Star the key event, import it into Google Ads, and read one report: sign-ups by campaign.

That last report is the payoff. It is the difference between defending a budget with click counts and defending it with sign-ups, and it takes an afternoon to earn. If the afternoon still feels like a tax on your week, this is the kind of foundation we wire for clients at Supernodes: the pilot starts with an audit of what you already track, connects the key events for the forms that matter, and hands the reporting back within two weeks.