Viewability comes up in almost every conversation we have with publishers. Someone on the commercial side has been told by an agency that their viewability rate needs to improve and the first suggestion is always the same: lazy load the ads.

On the surface, this makes total sense. Simply don’t load the ad until the user scrolls to it. The ad appears when the user is looking at it. Viewability goes up. Boom, problem solved.

Except, as we’ve discovered through years of trial and error with Tradecore, it doesn’t work like that. Lazy loading can improve viewability and harm it at the same time, in ways that are genuinely hard to predict. I’ve implemented viewability measurement in multiple ad servers and video players over the years, and the mechanics of how this actually works are almost never discussed properly. So let’s do that.

WHAT VIEWABILITY ACTUALLY MEASURES (AND WHERE IT FALLS APART)

The Media Rating Council (MRC) standard for a viewable display impression is straightforward enough. It states that 50% of the ad’s pixels must be visible in the browser viewport for at least one continuous second. For large ads (242,500 pixels or more), the threshold drops to 30%. For video, it’s 50% of pixels for two continuous seconds.

Simple. But the thing everyone forgets is when that measurement starts. Viewability measurement does not begin when the ad slot it called in. In fact, viewability measurement doesn’t even kick in until the creative has loaded.

This is the primary reason you can never achieve perfect viewability and is also the reason most of the advice you’ll read about improving viewability rates misses the point entirely.

THE HIDDEN BOTTLENECK: CREATIVE RENDER TIME

Think about what happens when an ad wins an auction. The creative still has to load. Most advertisers are running HTML5 ads served through Google that use a heavyweight JavaScript animation framework, plus Google’s own HTML5 Enabler.js framework (which is not small). On top of that, you often have an added layer of IAS or DoubleVerify verification, which adds another network hop before anything appears on screen.

These ads do not render instantly. They can take several seconds. During those seconds, the viewability clock hasn’t started yet, but neither has the user’s scroll behaviour stopped.

The speed at which an advertiser’s creative renders is oftentimes a bigger factor in viewability than anything the publisher does. And publishers have zero control over it.

The entire conversation around viewability improvement tends to focus on what the publisher can change: ad placement, layout, lazy loading, refresh rates. And, while all of that has an impact, the single largest variable in whether an impression registers as viewable is often how quickly the buyer’s creative gets itself together.

WHY LAZY LOADING CAN MAKE THINGS WORSE

Lazy loading delays serving the ad until the user scrolls to that part of the page. Intuitively, that sounds like it should help. But when you scroll down to a lazy-loaded ad slot, the ad still has to go through the entire auction and render pipeline.

So the user scrolls to the slot. The auction fires, the bids come in and a winner is selected. Only then, the creative starts loading. Meanwhile, the user is still scrolling. By the time the ad actually renders, the user may have already scrolled past it. The viewability window opens after the user has left.

If that same ad had loaded with the initial page render (the traditional approach), it would have had a head start. The auction would have completed while the user was still reading the top of the page. The creative would have had time to load. By the time the user scrolled down, the ad would already be rendered and the viewability clock would already be ticking.

Lazy loading trades a definite head start for a theoretical alignment with scroll position. Sometimes that trade works. Often it doesn’t.

THE HIDDEN AUCTION COST

There’s another dimension here that’s purely economic. On a typical homepage, you might have eight to ten ad slots. In a standard setup, you can auction all of those slots simultaneously in a single batch of bid requests to your header bidding partners and to GAM.

With lazy loading, each slot fires its own auction when the user scrolls to it. That means separate bid requests for each slot. More network calls and more latency, of course, means more opportunities for timeouts.

This is addressable if you coordinate on a strategy to insert slots in batches rather than one at a time, but that adds complexity. And complexity in ad serving is where revenue vanishes into the ether.

WHAT ACTUALLY DETERMINES ABOVE-THE-FOLD AD SPEED

If lazy loading isn’t the answer for above-the-fold ads (and it isn’t, because there’s nothing to lazy load when the ad is already in view), then what determines how quickly those ads appear?

We monitor the full render pipeline across our publisher network. Here’s what a well-optimised news site looks like on average:

• Time before the header bidding script is called and fully loaded: 1.37s
• Time waiting for consent (CMP) to be ready: 379ms
• Total Amazon and Prebid auction duration: 1.44s
• GAM decision duration: 970ms
• GAM render duration: 81ms
• Average fully rendered time: 4.37s

That’s 4.37 seconds from page load to a rendered ad. For context, many competitor publisher sites we’ve benchmarked sit in the 5 to 10 second range. So this is already faster than average.

But “faster than average” isn’t really the bar anyone wants to clear. So how do you actually improve on this?

THE LEVERS FOR IMPROVING AD SPEED AND VIEWABILITY

Now, let’s get to the good bit where we give you concrete steps on how publishers can improve viewability in 2026.

1. PRIORITISE YOUR HEADER SCRIPT AND CONSENT MANAGER

The header bidding script and your CMP (Ketch, OneTrust, whatever you’re running) must load as early as possible. Every millisecond of delay here pushes the entire pipeline back. If these are being deferred behind other scripts, that’s the first thing to fix.

2. REDUCE INITIAL LOAD CONTENTION

This is the big one that nobody wants to hear. Everything in your page is connected. Every script competes for the browser’s attention. Modern browsers are fast at loading multiple things concurrently, but they cannot load and execute every single script at the exact same instant.

Below-the-fold third-party content (commenting widgets, content recommendation engines, social embeds) should be lazy loaded or at least delayed. These are not above-the-fold experiences. They do not need to compete with your ad stack for initial load priority. But on most publisher sites, they do. And it has a measurable impact.

3. DEAL WITH SYNC PIXEL STORMS

This one is technical but important. Third-party widgets and content recommendation platforms, or vendors offering you a “incremental revenue format” don’t just load their own scripts. They also trigger storms of user sync pixels, which are themselves JavaScript-driven network requests. These run in the same execution thread as everything else, including viewability measurement.

Viewability is measured with JavaScript. It is timing-sensitive. If you have a lot of other JavaScript competing for execution time during those critical first seconds, measurement responsiveness degrades. An ad might be perfectly visible to the user, but the measurement script can’t confirm that quickly enough because it’s contending with sync pixel traffic from a commenting widget the user hasn’t scrolled to yet.

4. RETHINK YOUR OPEN BIDDING EXPOSURE

Google’s Open Bidding (formerly Exchange Bidding) adds server-side auction participants to the GAM decision. In theory, more competition means higher CPMs. In practice, Open Bidding adds significant latency at peak traffic times, and Google has been clear that they can’t make it faster.

The question publishers should be asking is whether the marginal revenue from Open Bidding justifies the speed cost across every impression, not just the ones it wins. In our experience, it often doesn’t, but this varies by site and the only way to know for certain is to test with it disabled and measure the difference.

5. USE SMARTER AD REFRESH STRATEGIES

Ad refresh is where viewability and monetisation intersect most directly, and where the approach matters far more than the fact of refreshing.

The basics: refresh should only happen when the page is visible and on-screen. If a user has tabbed away, refreshing into the void burns an impression and tanks viewability. That’s table stakes.

Beyond that, there are three levels of sophistication:

Viewport-limited refresh only refreshes ads that are currently in the user’s viewport. This directly improves viewability because you’re not refreshing ads the user can’t see. The trade-off is reduced total impressions, which can reduce short-term earnings. Viewability improvements may eventually be reflected in higher CPMs, but the market takes time to react to that.

Bid-aware refresh is, in our opinion, the more interesting approach. Rather than refreshing on a fixed timer, you refresh based on bid availability and bid value. If there’s strong demand for the next impression, refresh. If not, hold the current ad and let it accrue more viewability time. We developed this recently and early testing has shown it has potential to improve both viewability and monetisation simultaneously, which is the outcome everyone wants and very few approaches actually deliver.

A PRACTICAL CHECKLIST FOR PUBLISHERS

If you’re being told to improve viewability, here’s where to focus your effort, roughly in order of impact:

Audit your third-party script load order. Identify everything that loads in the initial page render and ask whether it genuinely needs to be there. Commenting widgets, recommendation engines and social embeds almost certainly don’t.

Check your consent manager timing. If your CMP is loading late or blocking the ad stack, that’s free speed sitting on the table.

Measure your actual render pipeline. Not estimates, not assumptions. Instrument it. Know how long each stage takes so you can identify where the bottleneck actually is rather than guessing.

Evaluate Open Bidding. Run a clean A/B test with it disabled. Compare the revenue difference against the speed improvement. Make the decision with data.

Consider viewport-limited refresh. Test it. Measure the viewability improvement against any earnings impact. The numbers will tell you whether it’s worth it for your traffic profile.

Explore bid-aware refresh. If your ad platform supports it, this is the highest-potential optimisation available today for balancing viewability with yield.

And finally: talk to your demand partners about creative weight. This is the conversation the industry avoids having because it puts responsibility on the buy side. But if a 2MB HTML5 creative takes four seconds to render, no amount of publisher-side optimisation will make that impression viewable.

IN SUMMARY

Viewability is not a single metric you can fix with a single change. It’s the output of a system with dozens of moving parts, many of which are outside the publisher’s control. Lazy loading is one tool in that system, not a solution. Ad refresh strategy, script load priority, third-party contention and creative render time all matter at least as much, and often more.

You cannot set meaningful expectations for improving viewability without understanding the mechanics of everything at play. Anyone who tells you otherwise is selling you a shortcut that doesn’t exist.