Get advanced level skills at Google Tag Manager

Introduction to the course topics and content.

In the first lesson, we’ll start with Google Tag Manager’s event tracking model. You’ll learn about GTM’s data model, how the dataLayer interacts with GTM’s complex data structures, and how automatic event tracking makes use of these interactions to help you track user activity on the website.

You’ll learn:

• What happens when you execute a dataLayer.push() - and understanding this is crucial if you want to build and design complex Google Tag Manager implementations.
• How to use auto-event tracking effectively - and why this is one of the most useful ways to put Google Tag Manager to use on a site.
• How to solve issues with GTM’s auto-event tracking - and how you can save hours of detective work once you figure out the common reasons for why event tracking breaks.

Using Google Tag Manager’s auto-event tracking is great when you want to measure clicks and form submissions. But what if you want to measure interactions with your form? Or when the user hovers over an image but doesn’t click it? Or how much time the user actually spent on the page? You’ll need to create your own event listeners for these use cases.

This lesson will cover:

• How the JavaScript event handling model works  - and how you can utilize it to fix issues with tracking form submissions, for example.
• What different types of browser events can be tracked - and just how much potential there is in tracking these with Google Tag Manager.
• How to build your own event listeners - because sometimes GTM’s own native auto-event listeners are simply not enough.

Google Analytics uses a tracker object data structure to make sure that interactions on the website are compiled into well-formed Google Analytics requests and hits. In this lesson, we’ll discuss how this tracker object works, and why it has some serious implications for Google Tag Manager implementations.

We’ll address:

• How the tracker object works - and why it’s such an important asset in building Google Analytics tracking on a website.
• How the tracker object interacts with Google Tag Manager - spoiler alert: it’s not smooth sailing. GTM has an idiosyncratic approach to how it utilizes the tracker object.

• How to identify and fix issues with single-page applications - the biggest problem is how to measure single-page applications correctly in Google Analytics, when using Google Tag Manager as the implementation tool.

customTask is the greatest tool at your disposal for customizing your Google Analytics implementations. In this lesson, we’ll discuss why this is so, and how you can do things like PII removal and hit multiplication with ease when using customTask.

This lesson will guide you through:

• What “tasks” in Google Analytics are - and how each one contributes to building the GA hit.
• How customTask works and what makes it special

• What you can do with customTask - and how you can utilize tools found online to make every line of code in customTask count.

Enhanced Ecommerce is one of the most interesting reporting models in Google Analytics. However, implementation is not straight-forward, and many of the quirks with Enhanced Ecommerce are poorly documented. With this lesson, many of these features become more clear, and your future implementations will thank you.

We’ll cover:

• The role of the dataLayer in Enhanced Ecommerce - and how the rigid data structure can be its own undoing.
• How to use the Custom JavaScript variable method - useful if you don’t want to be subservient to a costly refactor operation on your Ecommerce dataLayer.
• Lessons learned through years of experience - there are lots of “huh?” situations with Enhanced Ecommerce data, and we’ll go over some of the more prominent ones in this lesson.

Google Tag Manager’s API can save your organization hundreds of hours of manual labor, as you learn how to write scripts that automate many of the menial tasks. If you’re struggling with dozens of containers that require constant upkeep, the API will soon become your best friend.

This lesson will guide you through:

• What the GTM API is - and how it will save you time in the long run.
• What resources and methods are available through the API - including many use cases for which the API can be a life-saver.
• How to try out the API - and just how easy it is to use the tools available.

We’ll take the learnings from the previous lesson, and put them to practice in this one. You’ll learn how to build a simple but extendable Google Sheets extension, which pulls in data from the Google Tag Manager API.

Set yourself up for success with:

• How to build Google Sheets extensions - it’s easier than you think!
• How to utilize the Google Tag Manager API in Sheets’ Apps Script - build your own documentation tool that you can start using immediately.

Custom Templates in Google Tag Manager allow you to build branded user interfaces for the custom scripts that would otherwise need to deployed with Custom HTML tags and Custom JavaScript variables.

In this lesson, we’ll cover:

• Why you should get into the habit of using Custom Templates - and why getting rid of Custom HTML tags and Custom JavaScript variables is a good idea.
• How the template editor works - and how you can navigate it for testing and debugging, too.
• What the “Sandbox JavaScript” is and what you need to know about it - why has GTM created its own flavor of JavaScript, and how does it work?

You’ll put the learnings from the previous lesson to good use as you build your own Custom Tag Template. You’ll also learn the end-to-end process of building and distributing a template.

In this last lesson, we’ll cover:

• How to build the fields, the code, and the permissions of a custom tag template
• How (and where) to distribute it to maximize your brand visibility