Your Google tag is becoming a container: what changes in January 2027
On 17 November 2026 Google published a Tag Manager release titled "Google tag and Google Tag Manager unification". The direction was visible in August, when the Overview page was reorganised and the Google tag started being described as a container. The new note states the endpoint: "We're bringing all the capabilities of Google Tag Manager to the Google tag. With these upgrades, each Google tag becomes a Tag Manager container."
Two details in that note carry a date or a setting, and both land on sites that never opened Tag Manager. One is January 2027, when installations Google classifies as unsupported get upgraded whether or not anyone prepared for it. The other is a checkbox inside the Initialization trigger that decides whether destination tags wait for an in-page gtag('config') command or fire on their own.
What the release actually promises
The first sentence is the big one, and it is narrower than it sounds. Sites that only run a Google tag, never a GTM- container, gain access to Tag Manager's interface. Google's wording is that these sites "will have the ability to use Tag Manager's interface-driven tagging features, debugging, and version control".
The upgrade does not rewrite what runs in the browser. Google states that it "won't change the in-page behavior of the Google tags". Each Google destination gets its own tag, and the note says this preserves existing setup and triggers for automation events. Measurement that arrives on your property today should still arrive tomorrow, from the same tag, at roughly the same moment.
What moves is where configuration lives. All new deployment snippets become the same snippet, and they no longer carry a gtag('config') command. Initialization behaviour moves to the standard GTM Initialization trigger, which is where a container has always configured "run this before anything else". That trigger is also where Google put the escape hatch for sites still depending on the old command, covered below.
The set of IDs affected is wider than a single product. Google's help page for the setting names G-, AW-, DC- and GT- prefixes as containers that were created and used as a Google tag before becoming Tag Manager containers. Analytics, Google Ads, Display and Video 360, and plain Google tag installs all sit in that group. A site running a tag for each product is not a special case, it is the normal case.
Which installations are "unsupported", and why the path decides
January 2027 is the sentence that should get a site owner moving. Google's note says: "If you have an unsupported installation, you'll receive the upgrade in January 2027, and are advised to adjust your setup before then."
"Unsupported installation" has a specific meaning, and it is about the script path rather than the account. The July 2026 release described the same class of setup: containers loaded from paths such as /gtag/js or /gtag/destination used to degrade into a restricted state where only Google-provided tags and variables could run. The correction at the time was to make the container ID, not the path, decide the restriction.
The rule now reads like this. An ID starting with GTM- permits all tag types, including custom HTML, custom JavaScript and third-party scripts. A product-specific prefix such as G- or AW- limits the container to Google tags, so it can send data to Google services and nothing else. Google's help page is explicit that the ID "controls this behavior regardless of the installation path you use, including paths like /gtag/js or /gtag/destination".
Why that matters before January: when a G- or AW- installation becomes a full Tag Manager container, the container's permission model and version history come with it. Someone on the site team needs to be able to open it, review what the upgrade did, and publish or revert. If nobody holds that access, because the tag was always managed through a platform integration or an agency login, the upgrade arrives with no owner.
The checkbox that decides whether tags keep firing
Here is the part that turns a quiet upgrade into a lost-data incident. Google added a setting called "Support gtag('config') initialization events" to the Initialization trigger. It appears only on web containers that were migrated from the Google tag, meaning containers created and used as a Google tag before they became Tag Manager containers. Standard GTM- containers never see it, because they already behave the standard way.
For a container loaded through the legacy /gtag/js script path, the checkbox changes the moment the trigger fires:
- Checked, which is the migrated default. Destination tags wait until the page runs a
gtag('config')command whose ID appears in the allowed container IDs list. Parameters passed in that command are merged into the tag configuration, and where the same parameter is set in both places the Tag Manager UI value wins. - Unchecked. Destination tags fire during the normal initialization loop as soon as the container loads, without waiting for any in-page command.
Containers loaded through /gtm.js are unaffected either way. They initialize immediately on container load, after consent initialization and before any other trigger, and ignore in-page config commands entirely.
The trap is the combination nobody plans: leave the box checked and remove the gtag('config') line from the site while the old snippet keeps loading. Google's warning is blunt. Destination tags will not fire, and Tag Diagnostics shows an alert that tags are waiting for an in-page config command that no longer exists. A theme rebuild, a template edit or a switch to a new consent wrapper does exactly that without anyone noticing the tag is waiting.
The site still loads, the pages look right, and the container still reports as installed, so nothing on the front end says collection stopped. The evidence sits in Tag Diagnostics and in the absence of new events.
What unchecking costs, and why it is still the right direction
Google recommends turning legacy support off eventually, for a reason that is hard to argue with: waiting for a line of code on your own page is slower and depends on something outside the container. But unchecking is a measurement-affecting change, and the help page lists four consequences worth reading before anyone touches the setting.
Configuration parameters in the in-page command stop being applied at initialization. That includes send_page_view, user_id, currency, linker settings and any custom event parameters. They need to be copied into the destination tag in the Tag Manager UI first, or they simply disappear from collection.
Automatic page views get sent on container load, which is earlier than before. If the platform also sends its own page view, through an ecommerce integration, an app-managed pixel or a manual page_view event, the result is duplicate page views. Check for other sources before turning the setting off, not after.
Event ordering and values can shift. Anything the page sets shortly after load, through gtag('set') or a data layer push that runs late, may not exist yet when the tag fires.
Stale commands go inert. Existing gtag('config') lines can stay on the page without effect, and Google suggests removing them once the migration is finished to keep pages simpler and faster.
The migration order Google recommends
The published sequence is short and holds up:
- Inventory every parameter passed in
gtag('config'), including ones applied on only some pages. - Move those settings into the corresponding destination tag in the Tag Manager UI.
- Confirm no platform integration, plugin or custom code will send a second page view once the tag fires at initialization.
- Uncheck the box on the Initialization trigger.
- Preview in Tag Assistant and confirm the tag fires on initialization, the expected parameters are present, and exactly one page view is sent per page.
- Publish, then watch page views, events and conversions for a few days.
There is a way back. Re-check the box, make sure the container IDs are in the allowed list, and publish again. Google also allows a split approach: keep one Initialization trigger with legacy support for the tags that still depend on in-page commands, and a standard trigger for everything else. If a config command uses an ID from a different container, that ID goes under additional container IDs and its settings get merged in.
For anyone who has not touched the container, the honest answer from Google is that no change is required. Existing installations remain supported. The work is optional, and it is scheduled.
Permissions now follow the container
The last line of the release affects people rather than tags. "Google Tag Manager permission settings will now apply across the board, meaning access to data in Tag Assistant will be managed through the container permissions you use in Google Tag Manager today."
That is a change in who can see what. Tag Assistant shows the events, parameters and consent signals a page sends, which is debugging data about real user sessions. Until now, a person with access to a Google tag could reasonably expect to read it. After the unification, that visibility is decided by the container permission ladder: no access, read, edit, approve, publish. Edit allows workspaces and changes but not creating versions or publishing. Approve allows versions but still not publishing. Read opens the container without letting anyone change it.
Two facts from Google's permissions page deserve a place in any handover. Direct permissions persist even when an inherited permission is lost, so removing someone from a group does not necessarily remove their access. And an account or container left with no admin is deleted automatically, with read-access users given 30 days to export it from the trash before the site has to be retagged from scratch.
The practical consequence: an agency that manages a G- tag through a platform login, and has never held container permission, may find that its debugging access now depends on someone else granting it. Fix that before January rather than during the upgrade window. Google's guidance has not changed: more than one administrator on real user accounts rather than shared logins, and the account managed from inside the organisation.
What to do this month
Four checks cover most of the risk, and the first three are read-only.
- Find out which ID your site loads and from which path. A
G-orAW-ID, or a snippet pointing at/gtag/js, puts you in the January group. - Open the container and check whether the Initialization trigger carries the "Support
gtag('config')initialization events" checkbox. If it does, the container was migrated and the setting is live. - Search the site for
gtag('config')calls and list the parameters each one passes. That list is what has to move into the UI before the box comes off. - Confirm who holds at least read access to the container, and add a second administrator if the only one is an individual account somebody could lose.
The pattern is familiar from every platform migration: the announcement is about features, and the risk is about a quiet dependency nobody documented. Here the dependency is a single line of JavaScript on the page, and the deadline is a release note most sites will never read. Four months is enough time to do this properly. It is also enough time to forget, which is how most of these stories end.
Running a Google tag you never opened in Tag Manager? Book a free tracking audit and we will identify the ID, the installation path, and the settings that have to move before January 2027, then test the result in preview before anything is published.