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.
- 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.
- List the steps that lead to each outcome. Viewing a service page, starting a form, viewing a product, adding to cart, beginning checkout.
- 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
| Event | When it fires | Key event? |
generate_lead | Confirmed submission of a lead form or booking | Yes |
qualify_lead | Lead marked qualified in the CRM (sent server-side or via import) | Often yes |
disqualify_lead | Lead marked unqualified | No |
working_lead | Sales has contacted the lead | No |
close_convert_lead | Lead became a customer | Yes, if sent reliably |
close_unconvert_lead | Lead closed lost | No |
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.
| Event | Parameters | Notes |
generate_lead | value, currency, form_name, lead_type | Value can be a fixed estimate per lead type; see below |
purchase | transaction_id, value, currency, tax, shipping, coupon, items | transaction_id is essential for deduplication |
begin_checkout | value, currency, items | Same item structure as purchase |
sign_up | method | For 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 event | Do not make it a key event |
generate_lead on confirmed submission | form_start, form_submit from enhanced measurement |
purchase | add_to_cart, begin_checkout |
A booked call (as generate_lead with a lead_type) | Thank-you page views |
| Phone calls, if measured reliably | Scrolls, video plays, time on page |
| A qualified lead from the CRM, if available | Clicks 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:
| Column | Example |
| Event name | generate_lead |
| Plain-English description | Someone successfully submitted the contact or quote form, or booked a call |
| Trigger and method | Data layer push on form success; Calendly event_scheduled message |
| Parameters | form_name, lead_type, value, currency |
| Key event | Yes, counted once per session |
| Sent to | GA4; Google Ads (primary); Meta (Lead) |
| Status and date live | Live, tested 2026-11-12 |
| Owner | Agency / 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
- For every event in the sheet, trigger it in GTM preview and confirm it appears once in GA4 DebugView with all listed parameters.
- Try failure cases: submit an invalid form, double-click submit, reload the thank-you page. None should produce an extra key event.
- Test on a phone, where embedded forms often behave differently.
- 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.