Whether you are using an enterprise solution like Tealium IQ or the free version of Google Tag Manager, working in tag management systems (TMS) has become a crucial part of your tech stack. According to a recent survey compiled by W3 Techs, roughly 49% of all websites use a TMS. With this tool becoming more prominent on the web, there are many benefits to using one. On the other hand, there are also some potential negatives if not implemented well.
Implement a Data Layer
The data layer is where all of the information relative to the user’s browsing session lives. Through the use of this you can set and capture user information such as details pertaining to their session, like ecommerce data and user data. While it may not be a requirement to have a data layer implemented, it is strongly recommended since it helps to provide more granular data like an item that a user added to their shopping cart or if a user is logged in.
Plan Before Implementation
Don’t rush into implementation, start with planning and developing processes for tag governance. How will the TMS workflow be managed?
Implementation Workflow:
- New Tracking or Tag Requests
What information is required for each type of request? - Review Process:
Who approves the different tracking and tagging requests? Are there compliance or security considerations? - QA Process:
What is the framework for QA? - Documentation:
Is the TMS implementation and tag governance documented?
Implementation Tips & Tricks
When building a strategy for your TMS, its crucial to focus on reusability and scalability. Some quick pointers that will help with reusability is the use of lookup tables to map variables in a manner that dynamically outputs values based on a set of conditions assigned. An example of that might be building out a lookup table that outputs a Pixel ID which dynamically changes based on the URL. As a result of focusing on the reuse of tags, you will also reduce the total number of tags which will keep the container/profile lean and reduce the impact the tags have on performance. Ensuring that your TMS is scalable typically goes hand-in-hand when building a strategy that focuses on reusability, this results in an easy-to-understand container/profile that is not bloated with hundreds or thousands of tags.
When adding tags into your TMS it’s wise to evaluate the impact the tag will have on performance. This can be done by understanding the type of tag you are adding, as not all items should be implemented via a tag manager. Some examples of items you would not want to add would be cookie banners, images, or other site features, as the resource loaded would delay causing poor user experience.
Develop a trigger/load rule building strategy to help keep the number of triggers/load rules configured to a minimum and promote reusability throughout the container/profile. This can be achieved by using custom events and lookup tables. Planning out the triggering/load rule events also helps reduce the load on any single event that occurs by dispersing them as custom events rather than overloading tags on page load.
Consider limiting the number of tags that fire on a pageview. If there are a large number of tags that trigger on the initial page load, it starts to take resources away from other tasks, which can have an impact on performance. Alternatively, you can use custom events, which will give you the ability to fire tags off as they happen.
It is highly recommended that you use variables/extensions when possible, whether they are JavaScript, DataLayer, Constants, etc. They can help to improve efficiency and accuracy throughout your TMS. An important note when creating variables/extensions: use a naming convention that details out what it is and ensure that the use-case for the variable is aligned with its objective. This can be something like creating a JavaScript variable that may also be re-used in other use cases, setting a universal name that explains what it is, and ensuring that the variable is built with the intention it will likely be re-used by other tags or triggers/load rules.
Develop Naming Convention
A consideration for your TMS strategy that you will thank yourself for doing down the road is deciding on a naming convention. This is a starting point for organizing items within your tag manager and will allow you to easily identify tags and minimize the risk of creating duplicate tags.
Document and enforce naming conventions when adding items and creating folders/labels. Categorizing folders/labels correctly is helpful. When naming versions/workspaces specifically detail the changes involved when you publish a change, and only allow approved users to make edits and publish those changes.
Create a Plan for ongoing Maintenance
Data Quality is still one of the top reasons why companies fail to use their data. According to Accenture, only 33% of companies trusted “their data enough to use it effectively and derive value from it.” Bad data can lead to poor customer experiences and mistrust across the organization. You need to periodically review your tag management system to ensure that you continue to align with best practices. At Zion & Zion, we recommend that you audit your tag manager at least twice a year.
What to look for:
- Duplicate tags
- Expired tags
- Missing or incorrectly configured tags
- Conflicting variables/extensions
- Outdated tag templates
- Excessive number of tags
- Ensuring PII is hashed before sent to 3rd party platforms
- Verifying your load order for your tags prioritizes when/where needed
- If applicable, verifying the consent tool is properly configured to block tags before consent and update consent state to fire tags after consented.
Final Thoughts
Even though you may have completed the initial implementation of your TMS, it is never truly finished. Setting up quarterly audits will help ensure that your TMS runs efficiently and stays in an orderly manner. Syncing these audits up with your code-sprint cycles can also help to understand if a code release has an effect on anything within the TMS.