Track Website Conversions with Google Tag Manager

Introduction

Tracking website conversions is one of the simplest changes that delivers the biggest return for Australian businesses that rely on digital leads and online sales. Whether you run a boutique law firm in Melbourne, a tradie business in Brisbane, an e-commerce store in Perth or a B2B SaaS company in Sydney, understanding which forms and calls-to-action actually generate enquiries lets you optimise marketing spend, close more deals and forecast revenue with confidence.

This article walks through a practical, step-by-step method to track form conversions using Google Tag Manager (GTM) and Google Analytics 4 (GA4). It follows the same method covered in a hands-on tutorial: use a thank-you page (URL) as a reliable trigger, create a custom GA4 event and tag in GTM, publish the changes and verify conversions in real time. The approach is robust for Australian websites of any size and avoids common pitfalls that produce noisy or duplicated events.

Table of Contents

• Why conversion tracking with Google Tag Manager and GA4 matters
• Use the thank-you page URL to trigger reliable conversion events
• Create a custom GA4 event and mark it as a conversion
• Configure a GTM Page View trigger for the thank-you URL
• Create a GA4 Event tag in GTM and add the measurement ID
• Publish GTM changes and verify in GA4 real-time reports
• Testing tips and troubleshooting
• Australian examples and use cases
• Conclusion

Why conversion tracking with Google Tag Manager and GA4 matters

Conversion tracking answers a simple but critical question: which marketing activities turn into tangible outcomes? In Australia, where marketing budgets are scrutinised and competition in many industries is tight, accurate conversion data does three important things:

• It shows which campaigns and channels generate leads and revenue so you can allocate spend effectively.
• It gives your sales and leadership teams a clean pipeline view, improving forecast accuracy.
• It reduces wasted effort by surfacing broken or underperforming forms and pages.

GA4 is now Google’s analytics platform and provides event-centric tracking. Google Tag Manager sits between your website and analytics tools, letting you deploy events without changing site code. This separation is powerful for businesses that need quick, auditable tracking changes without a developer sprint.

Use the thank-you page URL to trigger reliable conversion events

There are a few ways to detect form submissions: listening for form submit DOM events, using dataLayer pushes on successful submission, or redirecting users to a thank-you page after form completion. For many Australian websites, using a thank-you URL is the most reliable and least intrusive method — especially when forms trigger asynchronous behaviour or are embedded within search results and dynamic components.

Why the thank-you page approach is often best

• Reliability: a page load is a discrete, trackable moment in the browser lifecycle.
• Separation of concerns: no need to rely on fragile front-end form listeners or third-party form widgets.
• Easy debugging: you can paste the thank-you URL into a browser and trigger the same event for validation.

When to avoid the thank-you page method

If your website uses single-page application behaviour where no URL change occurs, or if the form must not redirect for UX reasons, you might prefer a dataLayer push or a DOM form submit listener. However, if redirecting to a dedicated thank-you page is feasible, it normally gives the cleanest results for attribution and avoids duplicate events.

Create a custom GA4 event and mark it as a conversion

Before wiring GTM, create an event in GA4 that will receive the generated hits. This step makes the event meaningful inside GA4 and enables conversion reporting.

Recommended event naming and parameters

Use a consistent, descriptive name. Examples:

• generate_lead
• form_submit_contact
• newsletter_signup

Keep names lowercase and use underscores for readability. You can also send parameters such as value, currency or form_id if you need revenue or funnel detail.

Steps to create a custom GA4 event (high level)

1. Open GA4 and navigate to the Events section.
2. Create a new event (or configure from existing events) and set the event name to your chosen value, e.g. generate_lead.
3. Optionally add parameters: value (e.g. estimated lead value), form_name, page_path.
4. Save, then mark the event as a conversion by toggling it to count as a conversion in the Conversions settings.

Marking the event inside GA4 ensures it appears in conversion reports and is used by audiences and attribution.

Configure a GTM Page View trigger for the thank-you URL

Now switch to Google Tag Manager to create a trigger that detects the thank-you page load. We’ll use a Page View trigger with a page path condition that matches the thank-you URL slug.

Why page path contains is a good choice

Using Page Path contains prevents mismatches when query strings or UTM parameters are appended. For example, if your thank-you page is /thank-you/submit, you can use a condition like Page Path contains thank-you.

Step-by-step: create the GTM trigger

1. Open Google Tag Manager and go to Triggers.
2. Click New and choose Trigger Type: Page View.
3. Set the trigger to fire on Some Page Views where Page Path contains thank-you (or the specific slug used by your site).
4. Name the trigger clearly, e.g. Page View — thank-you (generate_lead), and save.

Using a descriptive name helps other team members understand intent when they see the trigger in the workspace.

Create a GA4 Event tag in GTM and add the measurement ID

With the trigger in place we add a GA4 Event tag that sends the event to your GA4 property. The measurement ID links GTM to the correct GA4 data stream.

Where to find the measurement ID in GA4

The measurement ID is located on the Data Streams page within GA4. It typically looks like G-XXXXXXXXXX. You need to paste this value into the tag configuration in GTM so data is sent to the right property.

Create the GA4 Event tag (step-by-step)

1. In GTM, go to Tags and click New.
2. Choose Tag Type: GA4 Event.
3. Select or enter your Measurement ID for the GA4 Configuration. If you already have a GA4 Configuration tag, select that instead of entering the ID again.
4. In Event Name, enter the event name you created in GA4, for example generate_lead.
5. Optionally add Event Parameters, for example:
   • form_name: contact_us
   • value: 5
   • currency: AUD
6. Attach the trigger you created (Page View contains thank-you).
7. Name the tag clearly, e.g. GA4 Event — generate_lead (thank-you), and Save.

Using the GA4 Configuration tag as a central place for the measurement ID is cleaner when you manage multiple tags.

Sample tag configuration fields (for reference)

Field	Example Value
Tag Type	GA4 Event
Measurement ID	G-XXXXXXXXXX
Event Name	generate_lead
Trigger	Page View — thank-you (generate_lead)
Event Parameters	form_name: contact_us, value: 5, currency: AUD

Publish GTM changes and verify in GA4 real-time reports

Once your tag and trigger are set up, the next steps are to preview and publish. Previewing lets you check the configuration in a debug session. Publishing makes the changes live.

Preview first

• Click Preview in GTM to open the Tag Assistant and connect it to your website.
• Fill out the form on your site and submit so the site redirects to the thank-you page.
• In Tag Assistant you should see the Page View trigger fire and the GA4 Event tag fire as well.

Publish and check GA4 real-time

1. In GTM, click Submit to publish the workspace changes. Add a clear version name such as “Add generate_lead event” and a short description.
2. Open GA4 and go to the Real-time report.
3. Trigger the event again by submitting the form and confirm the event name generate_lead appears in the real-time list.

Seeing the event in real time proves the connection works. If you marked the event as a conversion inside GA4, conversion counts should update after a short period.

Testing tips and troubleshooting

Even simple setups can suffer from small issues. Here are practical checks and fixes that cover most Australian websites.

Common checks

• Ensure the measurement ID is correct and belongs to the GA4 property you intend to use.
• Verify the trigger condition matches the actual page path. Inspect the thank-you page URL in the browser (exclude query strings) and use a contains rule that matches a unique slug.
• Use GTM Preview to confirm the trigger fired and the tag sent the expected event.
• Check for multiple tags firing on the same action to avoid duplicate events. If you have a form widget that also pushes events, reconcile both sources.

Troubleshooting checklist

1. If the event doesn’t appear in GA4 real-time: confirm the GA4 Configuration is present on the page and there are no ad blockers blocking analytics scripts.
2. If counts are higher than expected: look for duplicate triggers (e.g. both DOM form submit and page view triggers firing). Consider debouncing or removing redundant handlers.
3. If the event appears but conversions don’t increment: ensure you marked the exact event name in GA4’s Conversions settings.
4. If the page doesn’t redirect to a thank-you page: implement a short redirect after successful submission or use a dataLayer event push instead.

Debugging tips specific to Australian environments

• Check regional content delivery networks (CDNs) or caching layers that might interfere with the thank-you redirect.
• Mobile network testing: some mobile carriers may cache aggressively — test on common Australian carriers and Wi-Fi.
• Privacy settings: Australian businesses often have legal obligations around data retention and privacy. Ensure your GA4 configuration aligns with your privacy policy and any consent management platform (CMP) you use. If you block analytics until consent is given, ensure the tag waits for consent events.

Australian examples and use cases

Below are real-world scenarios showing how Australian businesses can apply the thank-you page + GTM approach.

1. Law firm in Sydney — tracking contact form enquiries

Problem: The firm runs Google Ads and social campaigns but doesn’t know which campaigns produce meeting requests.

Approach: After a form submission, redirect users to /thanks-contact. Create a GTM Page View trigger for contains: thanks-contact, fire a generate_lead event with parameters practice_area and lead_value: 250 (internal estimate). Mark as conversion in GA4 and use the data to optimise paid spend by campaign and practice area.

2. E-commerce store in Melbourne — tracking newsletter signups and coupon downloads

Problem: The store needs to know how many visitors sign up for the newsletter and download the first-order coupon.

Approach: Use two thank-you pages: /thank-you-newsletter and /thank-you-coupon. Create two GTM triggers and two GA4 events (newsletter_signup, coupon_download). Include value parameter for monetisation modelling (e.g. expected lifetime value).

3. Tradie business in Brisbane — measuring booked job requests

Problem: The tradie wants to differentiate between general contact messages and booked job requests that require quoting.

Approach: Add a parameter to the form that indicates job type, or use separate thank-you pages for quote requests and general enquiries. Fire generate_lead with lead_type: quote and estimated_value. Use this data to evaluate Google Ads performance by suburb and job type.

4. B2B SaaS in Perth — tracking demo requests

Problem: Demo bookings are the primary KPI. The SaaS uses a single-page app for the signup flow.

Approach: If a redirect isn’t used, implement a dataLayer push on successful submission: dataLayer.push({event: 'generate_lead', form_name: 'demo_request'}). In GTM, create a Custom Event trigger for generate_lead and fire the GA4 Event tag. If redirecting is added later, the thank-you page approach can be used instead.

Conclusion

Tracking website conversions with Google Tag Manager and GA4 is a high-impact task that returns value quickly for Australian businesses. The thank-you page method — detecting a specific page path, firing a GA4 Event tag and marking that event as a conversion — is reliable, easy to test and straightforward to maintain.

Key takeaways:

• Use a dedicated thank-you page when possible for the most reliable tracking.
• Create a clear, consistent event name in GA4 (for example generate_lead) and mark it as a conversion.
• In GTM, create a Page View trigger matching the thank-you URL and attach it to a GA4 Event tag using your measurement ID.
• Always preview, test and then publish. Verify events in GA4 real-time reports and monitor for duplicates or missing events.

If you’ve implemented this flow, share what you tracked and the results you saw — for example, campaign changes, lift in leads or better ROI reporting. If you ran into issues during setup, describe the problem and the debugging steps you tried; that context helps others learn quicker.

Thanks for reading — and good luck turning your website form completions into reliable, actionable conversion data.