In 1995 I was in high school in Montana, and our family’s fly fishing site lived in a subfolder of montana.com. As I remember it, the domain belonged to Internet Connect Services, part of JSCorp, and the founder, Jeff Smith, was also the late night technician answering the phone. Measurement, at that point, meant that Jeff would drop some data from the server in a folder where I could look at it. Counts. That was the whole discipline.
A few years later my father and I built glaciertoyellowstone.com, with him writing the content and me running the site. I bolted on the free tools of the day: hit counters you pasted onto a page to watch a number go up, and a hosted search box from a company called Atomz, which crawled your pages and kept an index so visitors could actually find things. I even have the era in writing. In spring 2000, for a marketing class at the University of Montana, a classmate and I wrote an integrated marketing communications plan for a local nature center, and college me recommended they buy a real domain from Network Solutions, add an Atomz search box, post a privacy policy, and, my favorite line to rediscover, review “site statistics, which are provided by Internet Connect Services.” Twenty-six years later I am still telling people to go look at what their infrastructure already recorded. Some advice ages fine.
I love this history the way some people love baseball history. Not the trivia, the plays: who was measuring what, why the stat everyone quoted turned out to be the wrong one, and who figured out the number that actually correlated with winning. Because that is what this is. The thirty-year story of web measurement is a Moneyball story. The industry spent its first decade staring at the batting averages, and the whole game since has been the slow, contested discovery of on-base percentage. This history is scattered across dead blogs and vendor archives and is genuinely hard to find in one place, so here it is, era by era, from someone who was in the stands for all of it and on the field for a lot of it.
The box score era: server logs
Every web server keeps a diary. Each request that arrives gets one line in a log file: the requester’s IP address, a timestamp, the path asked for, the status code returned, the bytes sent. That is the whole primitive. The first analytics industry was just software that read that diary and tabulated it: Analog, Webalizer, and AWStats crunched the log into charts of “hits,” pageviews, top pages, and referrers. The log could even be configured to record how fast the server answered, roughly the statistic we now call Time to First Byte (TTFB).
Hits were the batting average of the early web: easy to compute, satisfying to quote, and only loosely related to winning. A page with ten images generated eleven hits, so the number mostly measured how you built your pages. An IP address was not a person; a corporate proxy could hide a thousand readers behind one address, and a caching server could serve your page all day without your log ever hearing about it. And the deepest flaw took years to sink in: the server saying 200 is not the same thing as a human seeing a page. As sites grew heavier, with images and ads and scripts stacked on top of the HyperText Markup Language (HTML), the gap between “we sent the bytes” and “the user saw something usable” became the real story, and the log, a diary written entirely on the server, could not tell it.
I lived at the bottom of this era’s stack, checking counts in the folder Jeff left for me, and I can report that we loved those numbers anyway. Watching a hit counter climb was the entire reward loop of running a website in 1997. We just were not measuring what we thought we were measuring.
The beacon revolution
The fix was a genuinely great play: move the measurement into the browser itself. The mechanism, which still powers most analytics today, is worth understanding because it is almost comically simple. You paste a small piece of JavaScript at the bottom of every page. When a real browser loads the page, the script wakes up inside it, gathers what it can see from the inside, and phones home by requesting a tiny invisible image, historically a one-by-one pixel, with the measurements packed into the request itself. The vendor’s server does nothing but catch those requests. The trick is that this “beacon” runs where the user is: it can see the screen size, the session, the pages in order, the visit as a human experienced it. The log saw requests; the beacon saw visitors. That is the on-base-percentage moment of this whole history, the switch from counting files to counting people.
Somewhere in that era I got my own first taste of it, a snippet pasted at the bottom of every page of the family site, though I will not swear to which vendor’s snippet it was. The vendors themselves became a real industry: Urchin on the log-plus-beacon side, WebSideStory, one of the original beacon pioneers, selling HitBox and HBX as hosted services. And then the industry consolidated fast, in two directions at once.
Down-market, Google announced it was buying Urchin in March 2005 and relaunched it that November as Google Analytics, free. Demand was so heavy Google closed new signups within a week and ran a lottery for invites. Below the enterprise tier, the paid web analytics market effectively ended that week. Up-market, the enterprise players merged instead of dying: WebSideStory bought Visual Sciences in 2006 and took its name, and Omniture acquired the combined company in January 2008 for $394 million. Then Adobe bought Omniture in September 2009 for approximately $1.8 billion, and that acquisition became Adobe Analytics.
Here is the part I did not appreciate until I traced it for this post: that consolidation swallowed my own history. WebSideStory had bought Atomz, the little search box on our family site, back in February 2005. So the search engine I bolted onto glaciertoyellowstone.com as a kid rode the same wave: Atomz into WebSideStory, WebSideStory into Visual Sciences, Visual Sciences into Omniture, Omniture into Adobe, where I would later work. The web measurement industry is a small town.
I was inside Adobe not long after, working on the e-commerce side, and I got a practitioner’s education in what beacon data is and is not. The friction I remember was not marketing versus IT. It was analytics versus the books. Our sales leaders did not want to hear numbers quoted from “Omniture,” because they never matched what SAP reported. The beacon saw the order go through; it did not see the cancellation two days later, or the downstream fallout. So there was a running effort to marry click data with real order data, and a running skepticism of any number that came from the tag. That skepticism was healthy, and I have carried it ever since: browser data tells you about behavior, and you should reconcile it against a system of record before you bet money on it.
There is a quieter version of the same lesson most teams still miss: Google Analytics samples your data once a report or exploration crosses its quota. The number on the dashboard is often an estimate wearing the costume of a count. Years later, when customers challenged our measurements at Yottaa because they disagreed with their own analytics, sampling was very often the explanation, and most people in the room had no idea it was happening.
One footnote on this era that completes the picture: when the iPhone’s App Store arrived, the beacon model hit a wall, because there is no page to paste JavaScript into inside a native app. Mobile analytics grew its own parallel industry of embedded software development kits (SDKs), with names like Flurry and Localytics, replaying the same evolution one platform over.
The developers get game film
While the marketers built beacons, developers were getting their own view into the browser, and for years the two groups watched entirely different film in entirely different meetings. Firebug let a developer watch the network waterfall in real time: every resource a page requested, in order, with timings, like a play-by-play of the page assembling itself. In July 2007 Steve Souders at Yahoo released YSlow, which sat on top of Firebug and graded your page A through F against a set of performance rules, and made “why is this slow” a checklist instead of a séance. Alongside the in-browser tools grew the synthetic testers, Pingdom and WebPageTest and their kin, robots that loaded your page from data centers around the world, on demand or on a schedule, and charted the results.
Synthetic testing deserves a moment of respect and a caveat. Its great virtue is consistency: the same robot, the same network, the same browser, every hour, which makes it superb at catching regressions. Its great vice is that no customer is a robot in a data center. Real users are on hotel Wi-Fi, three-year-old phones, and congested cell towers. The industry would spend the next decade slowly relearning that lesson under the banner of real user monitoring (RUM), which is just the beacon idea pointed at performance instead of marketing: measure the load as actual visitors experienced it, one beacon per session, and take the distribution seriously.
The league writes a rulebook: Navigation Timing
Through all of this, every tool was inventing its own stopwatch, and none of the stopwatches agreed. The turning point, and in my opinion the most underrated event in this whole history, was standardization. The World Wide Web Consortium (W3C) Navigation Timing specification, which became a Recommendation in December 2012 after browsers had been shipping it for a couple of years, made the browser itself the official timekeeper. Any script on the page could now read performance.timing and get the same standardized timestamps everyone else got: when navigation started, when the connection was made, when the HTML arrived, when parsing finished, when the load event fired. Resource Timing followed and did the same for every individual asset. Paint Timing added when pixels first appeared, First Paint and First Contentful Paint (FCP). And the PerformanceObserver interface gave scripts a subscription model: tell me whenever a paint or a layout shift or a long task happens, and I will record it. Once those primitives existed, a performance beacon stopped being a vendor’s proprietary stopwatch and became a reporter of the browser’s own official times.
What the industry built on that common foundation was, naturally, a metric brand war, and I sat through that era’s pitch decks. New Relic put Apdex, an open satisfaction standard it popularized, on every dashboard. Dynatrace bundled signals into a user experience index. WebPageTest gave us Speed Index, computed from lab-run filmstrips rather than the browser’s own events. SpeedCurve talked about hero rendering times, and Akamai mapped request impact onto sessions. At Yottaa, where I was Chief Product Officer until May 2026, we focused the same primitives on the e-commerce case: checkout readiness and the behavior of third-party scripts. Every one of the RUM vendors’ branded numbers, ours included, was assembled from the same standardized browser events. Different scoreboards, same box score underneath.
That fact shaped how I ran the product. When customers were confused about why two tools disagreed, and they were always confused about why two tools disagreed, my standing answer was to open the books: here are the raw events we collect, here is how we compute the number, go check us. We did not sample; beacons still get blocked and dropped, so nobody sees everything, but what we stored was the full stream, not an extrapolation. Walking a customer through their own data was usually enough to rebuild trust in it.
The commissioner steps in: Core Web Vitals
Google ended the metric brand war the way only Google could: by picking the metrics and attaching them to search. Core Web Vitals arrived in May 2020 as three numbers with defined good/bad thresholds: Largest Contentful Paint (LCP) for how fast the main content shows up, Cumulative Layout Shift (CLS) for whether the page jumps around while you read it, First Input Delay (FID) for responsiveness to the first interaction. In June 2021 they became a ranking signal, and every executive who had never cared about milliseconds suddenly cared. It was the commissioner’s office stepping onto the field: you can keep your team’s proprietary stats, but these three go on the league table.
Inside Yottaa this was genuinely contentious, and I will own my side of the argument. A lot of smart people there could recite the deficiencies of the Core Web Vitals in their sleep, and they were not wrong on the technical merits. My argument was that the deficiencies did not matter, because the market had already decided; I had lived the receiving end at Gap, Inc., where we got our noses dragged through these exact numbers. I did not win that argument early. The market eventually won it for me.
The vitals themselves kept evolving. No metric is scripture. FID was retired and replaced by Interaction to Next Paint (INP) in March 2024, which watches interactions across the whole visit instead of only the first one, a much better measure of the sluggish-page feeling users actually complain about. And here is the detail that should keep every measurement vendor humble: for years the “gold standard” metrics could not even be measured in Safari. LCP and the event timing behind INP only landed in Safari 26.2 in December 2025, and CLS still is not supported outside Chromium. For a retailer whose traffic skews heavily toward iPhones, that meant the industry’s official scoreboard was blind to a huge share of real shoppers. Our mindset at Yottaa was to fill that gap for customers as credibly as we technically could, including polyfills where possible. We did not always pull it off, but the posture was the point: the browser is the source of truth, and when the browser goes quiet, say so, and estimate honestly.
Does the discipline pay? The last data I will personally vouch for came from the Web Performance Index we launched in September 2025, built on more than 500 million shopper sessions across 700-plus retail brands. Fewer than half of retail sites passed Core Web Vitals. Sessions with LCP around 1.3 seconds converted about 50 percent better than sessions at the 2.5-second passing threshold, and the gap between 200-millisecond and 50-millisecond INP was worth about 14 percent. Cohort data across 700 brands is not a controlled experiment, but it is a strong hint about where the money is. On-base percentage, it turns out, correlates with runs.
Extra innings: back to the logs
Here is the loop closing, and the reason I wanted this history written down. Real user monitoring runs on a JavaScript beacon, which means it only sees clients that run JavaScript and get far enough to fire it. The AI crawlers reading this site do not execute JavaScript at all, so my beacon never fires for them. Even the agents that drive a real browser rarely register: no agent clicks the cookie banner, so consent-gated tags never fire, and whatever does land in the dashboard is an anonymous Chrome session you cannot name. A whole new species of visitor is arriving, and the beacon era’s instruments cannot see it.
So when I wanted to know which AI agents were actually reading this site, no analytics dashboard could tell me. I went back to the server logs, the same place I started in 1995, in a folder Jeff Smith left for a high school kid in Montana. The server’s diary never stopped being written. Every era of this history added an instrument; none of them retired the previous one, and the oldest instrument is the only one that sees everything that touches your server.
If I compress thirty years of this into three sentences: Measure what the user experiences, not what the server sends. Know exactly how your number is computed, because someone will ask, and “open the books” is the only answer that survives. And keep reading your logs, because every new kind of visitor shows up there first. I still poke at vendors’ measurement beacons for fun on weekends with a public scorecard; some habits from 1995 are apparently permanent.
This piece began life as a sidebar in The Commerce Chain, an eBook I co-authored during my time as CPO at Yottaa and co-own today. I have corrected its facts where the world moved on (FID is gone, Safari finally ships LCP) and retold it here the way I lived it.