Skip to content

GA4Published 8 min read

GA4 Key Events and Naming Plan for Client Sites

How to design a GA4 event plan for lead-gen and e-commerce clients, decide which events become key events, and document it so the client can read it.

Muhammad Qitmeer, founder of Augere Labs
Muhammad Qitmeer
Co-founder and CEO, Augere Labs
Share

A good GA4 event plan names every event the site sends, lists its parameters and trigger, and marks only the handful of events that represent real business outcomes as key events: usually generate_lead for lead-gen and purchase for e-commerce. Use GA4's recommended event names wherever one fits, lowercase with underscores, push events through the data layer on confirmed success rather than button clicks, and keep the whole plan in a sheet the client can read without knowing GTM.

This guide is for agencies setting up or rebuilding tracking for client sites. The goal is a plan that survives a site rebuild, a change of agency and a client asking "what does this number mean". If you are auditing an existing property first, start with our GA4 audit checklist and come back here to design the replacement.

Start from outcomes, not from what can be tracked

GTM can track nearly anything. That is the problem. A plan built from "what can we capture" ends up with eighty events and no agreement on what a lead is. Build it from the other end.

  1. List the business outcomes. For a lead-gen client: form lead, booked call, phone call, maybe a qualified lead from the CRM later. For an e-commerce client: purchase, and possibly a subscription start.
  2. List the steps that lead to each outcome. Viewing a service page, starting a form, viewing a product, adding to cart, beginning checkout.
  3. Only then add engagement events that someone will actually use in a report or an audience.

If nobody can name the report or audience an event will feed, leave it out. You can add it later; removing an event that a dashboard depends on is harder.

Use GA4 recommended events where they fit

GA4 has a published list of recommended events with defined names and parameters. Using them gives you consistent naming, makes some built-in reports work (the e-commerce reports depend on them) and makes the plan easier for the next person to read.

Lead generation

EventWhen it firesKey event?
generate_leadConfirmed submission of a lead form or bookingYes
qualify_leadLead marked qualified in the CRM (sent server-side or via import)Often yes
disqualify_leadLead marked unqualifiedNo
working_leadSales has contacted the leadNo
close_convert_leadLead became a customerYes, if sent reliably
close_unconvert_leadLead closed lostNo

The later-stage lead events only make sense if the CRM can send them back with a way to match the original visitor. That is a bigger project; see CRM lead source attribution for HubSpot and GoHighLevel.

E-commerce

The standard funnel is view_item_list, view_item, add_to_cart, begin_checkout, add_shipping_info, add_payment_info and purchase, plus refund if refunds are tracked. Only purchase should normally be a key event. The rest are funnel steps and audience signals.

Shared events

sign_up and login for sites with accounts, search for site search (enhanced measurement uses view_search_results), and file_download or click from enhanced measurement where relevant.

Parameters: what each event carries

Event names say what happened. Parameters say which one and how much it was worth. Decide them up front.

EventParametersNotes
generate_leadvalue, currency, form_name, lead_typeValue can be a fixed estimate per lead type; see below
purchasetransaction_id, value, currency, tax, shipping, coupon, itemstransaction_id is essential for deduplication
begin_checkoutvalue, currency, itemsSame item structure as purchase
sign_upmethodFor example email or google

Custom parameters such as form_name or lead_type must be registered as custom dimensions in GA4 before they appear in standard reports. Standard properties have a limited number of custom dimension slots, so do not register every parameter by default; register the ones people will filter or break down by.

On lead value: a single value for every lead is better than none, and a value per lead type is better again. If the client sells a $5,000 service and roughly one in ten leads closes, a working estimate per lead is easy to agree. How to set those numbers is covered in assigning conversion values to leads.

Naming rules

Write the rules into the plan so nobody has to guess.

  • Lowercase with underscores for event and parameter names, matching GA4's own style: generate_lead, not Generate Lead or generate-lead. Names are case-sensitive in GA4.
  • Object then action, or action then object, but not both. GA4's recommended events are mostly verb first (add_to_cart, begin_checkout). Follow that pattern for custom events: click_phone, start_quote.
  • No variants in the name. One generate_lead event with a form_name parameter, not generate_lead_contact, generate_lead_quote and generate_lead_footer. Splitting by name multiplies key events and makes totals harder.
  • Respect limits and reserved names. Event names can be up to 40 characters, must start with a letter, and cannot use reserved prefixes such as google_, ga_ or firebase_.
  • No personal data in names or parameters. No emails, phone numbers or names sent to GA4.

Which events should be key events, and which should not

Key events are the events GA4 treats as outcomes for attribution and that you can import into Google Ads. The test for each candidate: would the client pay for more of this, on its own?

Make it a key eventDo not make it a key event
generate_lead on confirmed submissionform_start, form_submit from enhanced measurement
purchaseadd_to_cart, begin_checkout
A booked call (as generate_lead with a lead_type)Thank-you page views
Phone calls, if measured reliablyScrolls, video plays, time on page
A qualified lead from the CRM, if availableClicks on a phone number without a call duration check

Micro-conversions still have a role: they are useful for audiences and for diagnosing funnels. They just should not be key events, and they should never be primary conversion actions in Google Ads, because bidding will happily optimize toward cheap actions that do not pay. GA4 also lets you set each key event to count once per event or once per session; for leads, once per session is usually the safer choice.

Implementation: data layer pushes on confirmed success

The most reliable way to fire a lead event is a data layer push from the site's code at the moment the submission succeeds, then a GTM trigger on that custom event. For a form that posts with JavaScript:

window.dataLayer = window.dataLayer || [];
window.dataLayer.push({
  event: 'generate_lead',
  form_name: 'contact',
  lead_type: 'quote_request',
  value: 150,
  currency: 'USD'
});

Push it inside the success callback, not on button click. A click trigger fires on failed validation, double clicks and spam bots. For e-commerce, clear the previous ecommerce object first so values do not leak between events:

window.dataLayer.push({ ecommerce: null });
window.dataLayer.push({
  event: 'purchase',
  ecommerce: {
    transaction_id: 'ORD-10452',
    value: 89.00,
    currency: 'USD',
    items: [{ item_id: 'SKU-1', item_name: 'Example item', price: 89.00, quantity: 1 }]
  }
});

If the client's developer cannot add pushes, GTM's built-in options are a fallback: an element visibility trigger on the success message, or a page view on a dedicated thank-you URL that only loads after a real submission. Both work, both are more fragile than a push, and the plan should say which method each event uses.

AJAX and embedded forms

Embedded forms are where most lead tracking breaks. GTM's form submission trigger relies on a standard browser submit event, which many embedded tools never fire on the parent page. Each tool needs its own approach.

HubSpot forms

HubSpot's embedded forms post messages to the window when a form is submitted. Older embeds send a message with type hsFormCallback and an event name such as onFormSubmitted; HubSpot's newer forms expose their own global events for submission success. A small custom HTML tag in GTM listens for the right one and pushes generate_lead with the form ID as form_name. Check which form version the client uses before writing the listener, and test it again after any HubSpot form update.

Typeform

Typeform embeds are iframes. Use Typeform's embed SDK with its submit callback to push to the data layer, or send respondents to a thank-you URL on the client's own domain after submission and track that. Native Typeform integrations with GA4 exist, but check exactly what they send and to which property before relying on them.

Calendly

Calendly's embed sends browser messages to the parent page, including calendly.event_scheduled when a booking is completed. Listen for that message in GTM and push generate_lead with lead_type: 'booked_call'. Do not count calendly.date_and_time_selected; that fires before the person confirms. If Calendly is opened as a link to calendly.com rather than embedded, you also need to deal with referrals; see cross-domain tracking and self-referrals.

Other tools

Jotform, Gravity Forms, Contact Form 7, Elementor and others each have their own success hooks or events. The pattern is always the same: find the success signal the tool exposes, push one event on it, and confirm in DebugView that it fires once per real submission and never on a failed one.

Documenting the plan in a sheet the client can read

The plan is a deliverable, not an internal note. A client marketing manager should be able to open it and understand what each number in their reports means. Use one sheet with these columns:

ColumnExample
Event namegenerate_lead
Plain-English descriptionSomeone successfully submitted the contact or quote form, or booked a call
Trigger and methodData layer push on form success; Calendly event_scheduled message
Parametersform_name, lead_type, value, currency
Key eventYes, counted once per session
Sent toGA4; Google Ads (primary); Meta (Lead)
Status and date liveLive, tested 2026-11-12
OwnerAgency / client developer

Add a second tab listing custom dimensions and a third tab as a change log. When the same event also feeds Google Ads and Meta, list the destination names side by side so everyone can see that generate_lead in GA4, the "Lead form" conversion action in Google Ads and Lead in Meta are the same moment.

Testing the plan

  1. For every event in the sheet, trigger it in GTM preview and confirm it appears once in GA4 DebugView with all listed parameters.
  2. Try failure cases: submit an invalid form, double-click submit, reload the thank-you page. None should produce an extra key event.
  3. Test on a phone, where embedded forms often behave differently.
  4. After a few days, compare generate_lead counts with leads received in the CRM. They will not match exactly, but they should be close and move together.

Common mistakes

  • Marking every event as a key event "so we can see it".
  • Firing lead events on button click instead of confirmed success.
  • Different names for the same action on different forms.
  • Registering custom parameters in code but never as custom dimensions, then wondering why they are missing from reports.
  • A plan that lives only in GTM, with no document the client can read.

Getting the plan built

A clean event plan, the missing events implemented through GTM and a DebugView test log are exactly what our GA4 audit and setup delivers for each client account, under your agency's name.

Just one quick fix, not a whole account? Our founder takes small fixed-price jobs on Fiverr: GA4 and Google Tag Manager tracking fix

Frequently asked questions

How many key events should a GA4 property have?

For most lead-gen and e-commerce clients, between one and five. Each should be an outcome the client would pay for on its own, such as a lead, a booked call, a phone call or a purchase.

Should I use generate_lead or a custom event name for leads?

Use generate_lead. It is a GA4 recommended event, it reads clearly, and you can separate form types with a parameter such as form_name or lead_type instead of creating new event names.

Why doesn't GTM's form submission trigger catch my embedded form?

Embedded tools like HubSpot, Typeform and Calendly often run in iframes or submit with JavaScript, so no standard submit event reaches the page. Listen for the tool's own success message or callback and push an event to the data layer.

Do GA4 custom parameters show up in reports automatically?

No. Custom parameters must be registered as custom dimensions or metrics in GA4 before they appear in standard reports, and registration only applies to data collected after that point.

Should add_to_cart be a key event?

Usually not. It is useful for funnel analysis and audiences, but treating it as an outcome inflates conversion rates and, if imported to Google Ads as primary, pushes bidding toward carts instead of sales.

Muhammad Qitmeer

Written by

Muhammad Qitmeer, founder of Augere Labs

Augere Labs is the white-label tracking partner behind marketing agencies. If a client account has numbers you don't trust, I'm happy to look at it with you and tell you straight what's wrong.

Connect on LinkedIn