The Death of the Session

On 1 July 2023, Google’s Universal Analytics servers stopped processing hits from standard properties. Tags that had been firing since 2014 kept firing, into nothing. The property most sites had already migrated to, Google Analytics 4, still showed a number labeled “Sessions” at the top of its acquisition report, which made the whole transition look cosmetic. It was not. In Universal Analytics, a session was something the collection system created and stored. In GA4, a session is something the reporting system calculates after the fact, from a log of undifferentiated events. Twenty years of analytics vocabulary had just been demoted to a derived metric.

What Urchin Left Behind

The session was never a marketing concept. It started as a log-parsing workaround.

Urchin Software Corp., founded in San Diego in 1995 as Quantified Systems, sold a hybrid analytics product that read web-server log files and, later, page tags. Log files record requests, not people. To say anything at all about behavior, you have to group requests that probably came from the same visitor into a window of time, then declare the window closed when the requests stop. That grouping is the session. The thirty-minute inactivity timeout is not a finding about human attention spans. It is a heuristic for closing a bucket.

Google announced its acquisition of Urchin on 28 March 2005 and closed it that April. The price is widely cited as roughly $30 million, and Google never officially confirmed a figure. On 14 November 2005 the technology relaunched as Google Analytics, free of charge, and sign-ups were suspended within a week because demand outran capacity (Primo Interactive). Free enterprise-grade analytics did more than win a market. It standardized the session as the unit of web measurement for an entire industry: every dashboard, every agency report, every bonus target got built on top of it.

The tag itself evolved on schedule. urchin.js became ga.js in 2007, with an asynchronous version following in 2009. Universal Analytics reached general availability on 2 April 2014, bringing analytics.js, the Measurement Protocol, the User ID feature, and custom dimensions (BCS). What it did not bring was a different data model. UA collected typed hits: pageview, event, transaction, social, timing. The type was declared at collection time and baked into the schema, and everything downstream inherited that decision. Bounce rate meant a session containing exactly one hit. Goals were configured as thresholds over hits: a destination pageview, an event matching a category, a session-duration floor, a pages-per-session count. The reporting vocabulary was not a layer on top of the data. It was the data.

The Firebase Retrofit

Mobile broke it. Firebase Analytics, which Google ran for apps, had no pageviews to count and no server logs to parse. An app emits events: screen_view, first_open, in_app_purchase, plus whatever the developer defines. Sessions exist in that world as a reporting convenience, never as the primitive.

In July 2019, Google put a beta property called App + Web into Analytics. Its schema was Firebase’s, not UA’s. It was the first Google Analytics property in which a web pageview and an app screen view were the same kind of object. On 14 October 2020 that beta was renamed and shipped as Google Analytics 4 (Google blog). This one fact explains most of GA4’s ergonomics. It is a Firebase and BigQuery native product retrofitted onto the web, not an evolution of Universal Analytics. Marketers who migrated did not lose a feature set. They were moved onto a different product’s schema.

On 16 March 2022, Google announced the sunset (Search Engine Land). Standard UA properties stopped processing hits on 1 July 2023. UA 360 properties followed on 1 July 2024, and historical UA access was removed with them. There was no data migration path in either direction. Google’s stated reason is worth quoting, because it names the model rather than the interface: Universal Analytics “was built for a generation of online measurement that was anchored in the desktop web, independent sessions, and more easily observable data from cookies” (Google).

Three phrases in that sentence carry the whole argument. Desktop web. Independent sessions. Observable cookies. GA4 removes all three assumptions at the schema level, then reintroduces sessions as a calculation for the people who still have to report them.

One Primitive, Twenty-Five Parameters

GA4 has one hit type. It is called an event, and it carries a name plus up to 25 event_params, alongside user_properties scoped to the user rather than to the hit. page_view is an event. purchase is an event. session_start is an event, emitted when the tag decides a new session has begun. Sessions are derived from session_start plus a thirty-minute inactivity default, which means the same raw event log can yield different session counts if that definition changes.

What broke, concretely:

• Goals became conversion events. UA’s goal types had no GA4 equivalent, because they were defined over hit types that no longer exist. Every goal had to be remodelled as an event, and often as a new event the site was not yet emitting.
• Bounce rate lost its referent. A one-hit session means nothing when every interaction is a hit of the same type. GA4 led with engagement rate instead, then later reintroduced bounce rate as its arithmetic complement. That is not the metric UA reported.
• Ecommerce was rewritten. The items array is a repeated nested field on the event, not a transaction hit carrying product-scoped custom dimensions.
• The interface stopped answering questions the schema could answer. Anything involving an unaggregated event sequence moved into Explorations, or more often into BigQuery.

The gain is structural and real. A schema with one primitive can absorb a new measurement concept without Google shipping a new hit type. Server-side events, app events, offline conversion imports, and Measurement Protocol calls all land in the same table shape. The cost is that no reporting concept is authoritative anymore. Sessions, engaged sessions, and conversions are all definitions applied to a log, and a definition can be changed by a setting.

	Universal Analytics	Google Analytics 4
Primitive	typed hit: pageview, event, transaction, social, timing	one event, up to 25 parameters
Session	created and stored at collection time	derived from session_start plus a 30-minute inactivity default
Conversion definition	goal configured over hit types	event flagged as a conversion
Engagement metric	bounce rate, defined as a one-hit session	engagement rate, with bounce rate as its complement
Web and app	separate UA and Firebase properties, incompatible schemas	web and app data streams in one property
Warehouse access	BigQuery export, 360 customers only	BigQuery export in the free tier
Identity inputs	client-side cookie, optional User ID	cookie, User ID, Google Signals, modelled data

The Warehouse Was the Product

The clearest evidence that GA4’s real interface is a table rather than a report: Google put the BigQuery export in the free tier. Universal Analytics restricted the same capability to 360 customers at enterprise pricing.

A linked GA4 property writes to a dataset named analytics_<property_id>. Daily tables are events_YYYYMMDD. Streaming tables are events_intraday_YYYYMMDD, and each one is deleted once its corresponding daily table lands. Daily tables are restated for up to three days after the event date, to absorb late pings from devices that were offline, so any pipeline treating yesterday’s table as final will quietly undercount (GA4 BigQuery Export schema).

The schema is nested, not flat. event_params and user_properties are repeated RECORDs, which is why nearly every GA4 query opens with an UNNEST. items holds ecommerce line items. device, geo, and traffic_source carry context. collected_traffic_source records UTMs and click IDs as received, while session_traffic_source_last_click breaks attribution out per channel, with distinct fields for Google Ads, Search Ads 360, Display & Video 360, Campaign Manager 360, and manual tagging. Those click-ID fields are the join keys the rest of the stack runs on, and they get their own chapter in Join Keys: GCLID, Floodlight, and Attribution. privacy_info records the consent state each hit arrived with. The Sandbox tier gets daily tables and no intraday export.

Read that field list back against the UA schema and the inversion is plain. UA’s schema encoded what a hit meant. GA4’s schema encodes where a hit came from, what consent it carried, and which advertising system claims credit for it, then leaves the meaning to whoever writes the query.

Signals, Consent, and the Move to the Server

Three mechanisms sit on top of the event log, and each one changes what the log contains. None of them is an analytics feature in the Universal Analytics sense. They exist because Google runs the measurement layer and the advertising layer as one business, which is the argument One Company, Both Sides of the Table opens the book with.

Google Signals associates event data with signed-in Google accounts that have Ads Personalization enabled. That buys cross-device stitching, demographic and interest reporting, and remarketing audiences (Analytics Help). It is off by default, and switching it on has a price: it triggers aggressive row-level thresholding in reports, which is the subject of The Data You’re Not Allowed to See.

Consent Mode puts a gate in front of the tag. It carries four signals: ad_storage and analytics_storage, plus ad_user_data and ad_personalization added in v2. In basic mode, tags do not load until consent is granted, so a pre-consent visit generates no data at all. In advanced mode, tags load with consent defaulted to denied and send cookieless pings that carry the consent state and coarse context without writing identifiers, and those pings are what feed Google’s conversion modelling (Google tag documentation). Consent Mode v2 became mandatory for EEA and UK traffic feeding Google Ads on 6 March 2024, driven by the Digital Markets Act, and it requires a Google-certified consent management platform (iubenda). The consequence for the data model is that a conversion count in GA4 or Google Ads is now a blend of observed and modelled events, with the ratio set by a consent banner. Consent as an API takes that apart.

Server-side tagging moves the collection endpoint itself. A Google Tag Manager server container runs on Cloud Run or App Engine. A new entity type called a Client parses the inbound HTTP request, for instance a GA4 web tag’s hit, into an event data object, which is then fed into a virtual container where tags fan it out to vendor endpoints (Simo Ahava). What you get: cookies written in a first-party context, with longer lifetimes under Safari’s Intelligent Tracking Prevention; API credentials that stay server-side and never ship to a browser; and payload trimming before data leaves your own infrastructure. The container auto-fetches GA4 property configuration for tags with an overridden Measurement ID (Simo Ahava), and practitioners routinely use a “dataLayer relay” pattern to smuggle arbitrary dataLayer events server-side through the GA4 stream. The client-side plumbing that produces those events in the first place is The dataLayer Is a Message Bus.

Signals is an identity mechanism. Consent Mode is a legal mechanism. Server-side tagging is an infrastructure mechanism. All three exist because the conditions the session depended on, a durable cookie in a desktop browser making requests to one domain, stopped holding. The session did not die of neglect. It was load-bearing on a set of assumptions that expired, and Google’s response was to stop storing it and start computing it.

Which raises the obvious next question. If GA4 counts sessions on your site, and Google’s search index counts clicks on its results page, do those two numbers describe the same event? They do not, and the reason is structural rather than a defect. That is Two Views of One Click.

Key Sources

Source	Author/Org	Year	Link	Why it matters
The History of Google Analytics	Primo Interactive	n.d.	article	Dates the Urchin acquisition and the November 2005 free launch, including the suspended sign-ups
The History of Google Analytics	BCS	n.d.	article	Dates Universal Analytics’ general availability and its analytics.js feature set
Prepare for the future with Google Analytics 4	Google	2020	blog	The launch post that renamed App + Web, confirming GA4’s Firebase-schema origin
Google to deprecate Universal Analytics on July 1, 2023	Search Engine Land	2022	article	Fixes the 16 March 2022 sunset announcement and the shutdown dates
Upgrade to Google Analytics 4 before July 1	Google	2023	blog	Google’s own framing: UA was built for the desktop web, independent sessions, and observable cookies
GA4 BigQuery Export schema	Google Analytics Help	2020	docs	Field-level spec of the event log, including the three-day restatement window and privacy_info
About Google Signals	Google Analytics Help	2020	docs	Defines what Signals adds and why it is off by default
Consent mode overview	Google Tag Platform	2024	docs	The four consent signals, and how advanced mode’s cookieless pings feed modelling
Server-side Tagging in Google Tag Manager	Simo Ahava	n.d.	article	The clearest account of Clients turning HTTP requests into event data objects

PM Lens