How to Reduce Bounce Rate in GA4 (and When Not To Bother)
Your analytics dashboard shows a 75% bounce rate. You stare at it. Is your content terrible? Are visitors…

GA4 event tracking works completely differently from Universal Analytics. There’s no Category, no Action, no Label. Every user interaction — a pageview, a scroll, a purchase — is just an event with a name and a set of parameters you attach to it. That single shift changes everything about how you instrument a site.
I’ve spent years migrating clients from UA to GA4, and the one thing that consistently trips people up isn’t the interface. It’s not understanding which type of event to reach for and when. Once that clicks, the whole model makes sense.
Universal Analytics had six distinct hit types: pageviews, events, transactions, social, timing, and exceptions. Each had its own data model. Events specifically required you to fill in Category, Action, and optional Label and Value — a rigid structure that seemed logical until your team had ten people inventing their own conventions.
GA4 collapses all of that into one thing: events. A pageview is an event called page_view. A purchase is an event called purchase. A custom CTA click is whatever name you give it. Every event can carry up to 25 parameters providing context. That’s it.
| Feature | Universal Analytics | GA4 |
|---|---|---|
| Hit types | 6 (pageview, event, transaction, etc.) | Events only |
| Event structure | Category / Action / Label / Value | Event name + up to 25 parameters |
| Pageview tracking | Separate hit type | page_view event |
| E-commerce | Separate module with fixed schema | Built-in recommended events (purchase, add_to_cart, etc.) |
| Free-form metadata | None (fixed fields only) | Up to 25 custom parameters per event |
The practical upside: you describe what actually happened rather than forcing it into arbitrary boxes. The practical downside: more flexibility means more rope to hang yourself with if you don’t establish naming conventions early.
GA4 organises events into four types based on how they’re created. Knowing which category to reach for first will save you hours of unnecessary custom work.
| Type | How they fire | Examples | Configuration needed? |
|---|---|---|---|
| Automatically collected | Immediately on tag install | first_visit, session_start, page_view, user_engagement |
None |
| Enhanced measurement | Toggle in Data Stream settings | scroll, click, file_download, video_start |
Toggle on/off per stream |
| Recommended events | You send them; predefined schema | add_to_cart, purchase, generate_lead, sign_up |
Must implement via gtag or GTM |
| Custom events | You define name and all parameters | cta_click, sidebar_expand, quote_request |
Full implementation required |
The hierarchy here matters. Always check whether an automatically collected or enhanced measurement event already covers what you need before reaching for a custom implementation. In my experience, businesses often build elaborate GTM setups to track scroll depth — which enhanced measurement already handles out of the box.
These fire the moment your GA4 tag loads. first_visit triggers when someone visits your property for the first time. session_start fires at the beginning of each session. page_view runs on every page load (and on SPA virtual page changes if your tag is configured for it). You get this data with zero additional setup.
Enhanced measurement sits under Admin > Data Streams > your stream > Enhanced measurement. Toggle each option independently. Here’s exactly what each one tracks:
scroll when a user reaches 90% page depth. One threshold only; if you need 25%/50%/75%, you’ll need GTM.click with link_url and outbound: true when users leave your domain.view_search_results with the search_term parameter when GA4 detects a query string.video_start, video_progress (at 10/25/50/75%), and video_complete for embedded YouTube videos with JS API support enabled.file_download when users click links to PDF, CSV, XLS, DOCX, ZIP, and other common document types.form_start and form_submit. Reliability varies depending on how your forms are built; test before relying on this for conversion data.For a full list of what enhanced measurement fires and the parameters it attaches, see Google’s enhanced measurement documentation.
Before building any custom tracking, spend five minutes in Admin > Data Streams > Enhanced Measurement. Tick everything applicable to your site, then check DebugView. You may already have what you need.
Google publishes a recommended events list with predefined names and parameter schemas. Use them when they fit. purchase, add_to_cart, and begin_checkout unlock GA4’s e-commerce reports. generate_lead and sign_up feed predictive audiences. Custom event names don’t get those benefits.
Use custom events only when the recommended list genuinely doesn’t cover your use case. They’re fully flexible — you define the name, you define the parameters — but they don’t trigger any special reports in GA4. More on implementing them below.
If you’re using the GA4 tag directly (not through GTM), you send events with the gtag('event', ...) command. The syntax is straightforward:
// Basic custom event
gtag('event', 'cta_click', {
button_text: 'Start free trial',
button_location: 'hero_section'
});
// Recommended e-commerce event (add to cart)
gtag('event', 'add_to_cart', {
currency: 'USD',
value: 29.99,
items: [{
item_id: 'plan_pro',
item_name: 'Pro Plan',
price: 29.99,
quantity: 1
}]
});
The first argument is always the string 'event'. The second is your event name. The third is an object of parameters — key-value pairs that describe what happened. For recommended events, the parameter names are fixed by Google’s schema. For custom events, you choose them yourself.
The full gtag event reference is at developers.google.com/tag-platform/gtagjs/reference/events. Check it before naming parameters on recommended events — wrong parameter names mean the data lands but doesn’t feed the right reports.
Google Tag Manager is the most practical way to implement custom GA4 events for most teams. It keeps code off your site, lets non-developers adjust triggers, and gives you a version history for every change.
The basic setup in GTM for a GA4 event tag:
cta_click.dataLayer.push(), etc.A GTM dataLayer push for a custom event looks like this:
// Push from your site code when a specific action happens
window.dataLayer = window.dataLayer || [];
window.dataLayer.push({
'event': 'cta_click',
'button_text': 'Start free trial',
'button_location': 'hero_section',
'page_section': 'pricing'
});
In GTM, you’d then create a Custom Event trigger listening for cta_click, and a GA4 Event tag that fires on it — mapping the dataLayer variables to event parameters. This keeps your tracking logic decoupled from your site’s code.
If the data layer concept is new to you, the guide on what the data layer is and how it works explains the mechanics in plain language. Understanding it is fundamental to reliable GTM-based tracking.
Parameters are where GA4 gets genuinely powerful. Every event can carry up to 25 parameters that add context to what happened. For a cta_click event, you might send:
button_text: “Start free trial”button_location: “hero_section”page_path: “/pricing”However, there’s a catch most people discover the hard way. Parameters only appear in Realtime and DebugView by default. To use them in explorations, standard reports, or audiences, you must first register them as custom dimensions.
To register a custom dimension:
Standard GA4 properties support up to 50 event-scoped custom dimensions and 25 user-scoped custom dimensions. That sounds like a lot, but teams that track aggressively hit those limits. Plan your parameters before implementing — wasted slots can’t be recovered without deleting existing dimensions.
For the full custom dimensions documentation, see GA4 custom dimensions and metrics.
DebugView is GA4’s real-time event inspector. It shows every event firing from a debug-enabled device as it happens, with all parameters expanded. Use it to verify your implementation before going live.
To enable debug mode:
debug_mode: true to your event call during testing, then remove it before shipping.DebugView is under Admin > DebugView. You’ll see events appear on a timeline as they fire. Click any event to expand its parameters. If a parameter is missing, it either wasn’t sent correctly or wasn’t registered as a custom dimension yet.
GTM Preview and DebugView are two different verification steps — GTM Preview confirms that a tag fired, but only DebugView confirms that GA4 actually received and processed the data. Both matter. The full documentation for DebugView is at support.google.com/analytics/answer/7201382.
Naming is the thing that makes or breaks event tracking at scale. Inconsistent naming produces fragmented reports that nobody trusts. These are the rules I enforce on every implementation:
| Rule | Good example | Bad example |
|---|---|---|
| snake_case always | form_submit |
FormSubmit, form-submit |
| verb_noun format | download_pdf, play_video |
pdf, video_was_played |
| Descriptive but concise | newsletter_signup |
ns, user_signed_up_for_newsletter_from_homepage |
| No special characters | add_to_cart |
add-to-cart! |
| Under 40 characters | video_play |
user_clicked_play_button_on_video_player |
Also maintain a tracking plan — a spreadsheet that lists every event, its parameters, the trigger condition, the business question it answers, and who requested it. I’ve watched more tracking implementations fail from poor documentation than from technical mistakes. The code is the easy part.
Build the tracking plan before the tags. One row per event, one column per parameter. It takes an hour and saves weeks of cleanup later.
GA4 event tracking covers the full picture of what happens on your site: which events fire, what parameters they carry, how the event model works, and how to implement it. That’s this article.
Marking an event as a key event (what older docs called a “conversion”) is a separate step — you do it in Admin > Events by toggling an event as a key event. That designation affects how GA4 attributes value in reports and how conversions appear in your data. The specifics of that process, including which events to mark as key events and why, are covered in the guide to GA4 key events and setting up conversions.
Don’t confuse the two. An event fires data. A key event tells GA4 that this event represents a business goal. You need both, but they’re distinct concepts with distinct configuration steps.
After helping dozens of businesses with GA4 event tracking, the same problems come up repeatedly.
Enhanced measurement already handles scroll depth, outbound clicks, file downloads, site search, and YouTube video engagement. If you’re configuring GTM to replicate any of those, you’re doing double work and potentially producing duplicate events.
This is the most common one. You push button_location on every CTA click, then look for it in Explore and it’s not there. Parameters need to be registered in Admin > Custom Definitions before they surface outside Realtime and DebugView.
One developer writes button_click; marketing’s GTM container sends buttonClick; the agency adds btn_clicked. Now you have three events for the same interaction. Agree on a naming convention before anyone opens GTM.
GTM Preview shows that a tag fired. It does not confirm that GA4 received the event with correct parameters. Always open DebugView and confirm the event appears there with the right parameter values before publishing a container.
GA4 event tracking replaces the rigid Category/Action/Label model with something genuinely more flexible. Every interaction is an event with a name and parameters. The four event types — automatically collected, enhanced measurement, recommended, and custom — form a hierarchy you should work through in order, from the least to the most implementation effort.
Here’s a practical starting sequence:
If you’re starting from scratch with GA4, the GA4 setup guide from zero to first report covers the full property configuration before you get to event tracking. And if you’re using GTM for implementation, the data layer guide is worth reading first — it explains the communication layer between your site and GTM that custom events depend on.
Start with what you have. Enhanced measurement covers more than most teams realise. Build from there only when you have a specific business question an existing event can’t answer.
First published . Last updated .