GA4 Pipeline -Episode 2: Sending Events | How Data Leaves Your Site

--author Arif Khan | founder zinzu.io

Previous Episode 1: Define | Google Tag Manager

In episode 1, we looked at where events are defined. Now we move to the next step in the pipeline: Send

This is the moment data actually leaves your website or app.

What “send” means in GA4

Once an event is defined, it still needs to be delivered.

This happens through:

• gtag.js for websites

• GA4 SDKs for mobile apps

This layer is responsible for sending events. Nothing more.

It does not decide:

• Which events are important

• Whether the data makes sense

• How it will be analyzed

It sends exactly what it is given.

A simple scenario

An event has already been defined:

• Event name: page_view_pricing

• Trigger: page load

• Metadata: page URL

When the page loads:

• The trigger fires.

• The event is packaged.

• The event is sent to GA4

No interpretation happens here.

Where gtag fits

When Google Tag Manager is installed, the site loads a small script from Google.

This script:

• Pulls the latest GTM configuration

• Applies the defined events and triggers

• Uses gtag to send events when conditions are met

The code stays the same.

The configuration changes.

What the send layer actually does

• Packages the event

• Attaches metadata

• Sends it at the moment the trigger fires

That’s it.

It does not:

• Validate business meaning

• Clean data

• Fix modeling mistakes

If an event is poorly defined, it will still be sent faithfully.

Why this separation matters

When something looks wrong in GA4, the send layer is often blamed.

In practice, most issues come from:

• Unclear event definitions

• Triggers firing at the wrong time

• Incomplete or noisy metadata

The send layer does not correct upstream decisions.

Common misconceptions about gtag

• gtag does not decide what events exist

• gtag does not improve data quality

It transports events.

Everything else is handled downstream.

How this fits in the pipeline

• Define decides what an event is

• Send decides when it leaves the site

• Everything after that happens downstream

  
  

Each layer has a narrow responsibility by design.

If GTM shapes your data model, the send layer simply moves it forward.

Nothing more. Nothing less.

What’s Next?

After events are sent, they disappear from view.

What happens next is the most opaque part of GA4.

In the next episode, we’ll look at collection; how GA4 receives events, applies processing, and why the data you see later is not stored exactly as it was sent.

→ Next Episode 3: Collect | GA4 Collection & Processing

GA4 Pipeline -Episode 1: Google Tag Manager | Where GA4 Events Begin

--author Arif Khan | founder zinzu.io

Previous Episode 0: The GA4 Pipeline in One View

We’ll start with the first layer (Define) of the pipeline.

This is where Google Tag Manager comes into the picture.

Imagine you’re a marketer or analyst.

Your site already uses GA4, and GTM has been set up once.

Now you want to track visits to a specific page.

Without GTM

• Ask engineers to change code

• Wait for a sprint and deployment

• Everything slows down

  
  

With GTM

• Create an event in GTM

• Name it and set a trigger (for example, page load)

• Publish the change and deploy instantly

• No application code change

  
  

What GTM enables

• Define tracking without touching application code

• Speed up launches

• Test ideas without developer help

Code stays steady.

Tracking evolves fast.

What you define in Google Tag Manager

When you “create an event” in Google Tag Manager, you are defining three things.

1. Event name

   A clear name that describes what happened(for example: page_view_pricing).

   
   

2. Trigger

   The condition that decides when the event fires(for example: when a page loads or a button is clicked).

   
   

3. Metadata (parameters)

   Additional context sent with the event(page URL, button text, page category, content from textbox etc.).

That’s it. Everything else in GTM exists to support these three ideas.

Google Tag Manager as a data modeling layer

Google Tag Manager is often described as a “tagging tool.”

That description is incomplete.

In practice, GTM decides:

• What events exist

• When they are considered meaningful

• What context is attached to them

  
  

These are data modeling decisions, not implementation details.

Once an event name, trigger, and metadata are defined in GTM, every downstream system sees the world through that model.

If the model is clean, analysis is easy.

If the model is messy, no report can fix it.

Common GTM pitfalls

Most GA4 issues don’t start in reports. They start earlier.

• Inconsistent event naming

• Events firing at the wrong time

• Overloaded or unclear metadata

Small decisions here have large downstream impact.

GTM defines the shape of your data.

What’s next ?

Once events are defined, the next step is straightforward but often misunderstood:

How do events actually leave your site or app?

In the next episode, we’ll look at the send layer; gtag.js and mobile SDKs and clarify what this layer does, and just as importantly, what it does not do.

→ Next Episode 2: Send | gtag.js / Mobile SDKs