Setting Up GA4: Custom Dimensions for Granular Analysis

Welcome back. In our last lesson, we built a robust tracking system for the Meta Ads platform using Google Tag Manager, establishing a clean, event-driven data flow. You learned to distinguish between standard and custom events and how to enrich them with parameters—a crucial skill that directly applies to our topic today.

This lesson pivots from feeding data to an external ad platform to building our own, first-party analytics powerhouse: Google Analytics 4 (GA4). We will set up a new GA4 property from scratch and, more importantly, learn how to customize it to answer specific business questions. You'll discover that the event-based architecture you've already worked with is the fundamental principle of GA4. Our primary goal is to implement event-scoped and user-scoped custom dimensions, which will allow you to move beyond generic metrics and capture the unique data points that matter to your businesses.

1. The GA4 Paradigm Shift and Initial Setup

Before we begin, it's important to understand the fundamental architectural shift GA4 represents. Its predecessor, Universal Analytics (UA), was built around the concepts of sessions and pageviews. GA4 simplifies this by adopting a more flexible event-based data model, where every interaction—from a page_view to a purchase—is captured as an event with associated parameters.

This structure provides a much more granular and user-centric view of behavior, especially across different platforms (like a website and a mobile app). Since your background is in systems, you can think of this as moving from a rigid, hierarchical data structure to a more flexible, object-oriented model where events are the core objects.

Our first step is to create the GA4 property itself and perform some essential initial configurations. The following video provides a clear walkthrough of this process.

Once you have your Measurement ID, create a GA4 Configuration tag in GTM (now called the Google Tag) and set it to fire on all pages, just as we did for the Meta base pixel.

2. Custom Dimensions: The Key to Granular Analysis

With GA4 collecting standard data, the next step is to teach it about the specific attributes of your business. In the previous lesson, you sent parameters like value and currency with a purchase event to Meta. GA4 works similarly, but to use these custom parameters for analysis within the GA4 interface (e.g., in reports and filters), you must first register them as custom dimensions.

A dimension is an attribute of your data—it describes it. For example, Page title and City are standard dimensions. A custom dimension is one you define.

The most critical concept to master with custom dimensions is scope, which determines which events the dimension's value will be applied to. GA4 has three scopes, but we will focus on the two most common ones: event and user.

• Event Scope: The dimension applies only to the specific event it was sent with. Use this for attributes of an interaction, like form_id, button_text, or file_name.
• User Scope: The dimension applies to all subsequent events for that user from the moment it is set. Use this for persistent user attributes, like subscription_plan, user_role, or customer_tier.

The following guide from Analytics Mania provides an excellent, detailed explanation of these concepts.

For an even deeper architectural perspective, Simo Ahava's blog post is an invaluable resource. It clarifies the distinction between event parameters (which become event-scoped dimensions) and user properties (which become user-scoped dimensions).

3. Implementation: From GTM to GA4 Reports

Now, let's put theory into practice. The process involves two key stages:

1. Sending the Data: Use Google Tag Manager to send custom parameters with your GA4 events.
2. Registering the Dimension: In the GA4 interface, tell GA4 to "listen for" these parameters and make them available as dimensions in your reports.

We will follow the comprehensive guide from Analytics Mania to implement both an event-scoped and a user-scoped custom dimension.

3.1. Implementing an Event-Scoped Custom Dimension

Let's start by tracking clicks on your website's main navigation menu and capturing which link was clicked. This is a classic use case for an event-scoped dimension.

Remember to use GTM's Preview Mode and GA4's DebugView to verify that your menu_link_click event is firing correctly and that the menu_item_url and menu_item_name parameters are being sent as expected.

3.2. Implementing a User-Scoped Custom Dimension

Next, let's implement a user-scoped dimension. Imagine you want to track a user's subscription status (e.g., 'free' or 'premium'). This is an attribute of the user, not a single event, so it's a perfect fit for a user-scoped dimension.

The best practice for managing user properties in GTM is to use a Google Tag: Event Settings Variable. This follows the DRY (Don't Repeat Yourself) principle; you define the user property once in a variable, then apply that variable to all your GA4 tags. This ensures consistency and makes future updates much easier.

After implementing, be sure to test. When the user property is set (e.g., on login), you should see it appear in DebugView. From that point on, every subsequent event you trigger in that session should carry that user property with it.

Conclusion

In this lesson, you have established your own powerful, first-party analytics foundation. You've not only created a Google Analytics 4 property but have also gone far beyond the default setup by tailoring it to capture business-specific data. By mastering the concepts of scope and the implementation of custom dimensions, you can now analyze user behavior with a level of granularity that is simply not possible with out-of-the-box configurations.

Key Takeaways:

• GA4 is Event-Based: Every user interaction is an event, making the data model more flexible and user-centric than its predecessor.
• Initial Setup is Crucial: Correctly configuring data retention, internal traffic filters, and session timeouts from the start ensures data quality and long-term analytical capability.
• Scope Defines Application: The scope of a custom dimension (Event or User) determines how its value is associated with events and is the most critical concept to understand for correct implementation.
• Implementation is a Two-Step Process: You must first send a parameter from your tracking code (via GTM) and then register that parameter as a custom dimension in the GA4 interface.
• Use the Event Settings Variable: For user-scoped dimensions (user properties), using an Event Settings Variable in GTM is the most efficient and maintainable approach.

Now that you have configured your analytics platform to receive rich, contextual data, our next lesson will focus on standardizing one of the most important contexts: marketing campaign information. We will design and enforce a systematic UTM parameter schema to ensure you can accurately track the source, medium, and content that drives traffic and conversions on your site.