This post was most recently updated on September 15th, 2021
One common question we get from publishers is whether they can run up impressions using refreshes, single-page-apps (SPA), or short-form content (articles, slideshows, top lists, and quizzes broken up into many small pages). While they technically can run up impression counts using these techniques, publishers should understand what they’re doing, as most implementations of these strategies do not result in any significant long term revenue boost. Quite the opposite — they often result in long term revenue loss.
Here’s why: advertisers bid on a feedback loop. They buy the impression, and if the impression gets no engagement or it doesn’t meet their engagement targets, they either reduce their next round of bids accordingly, or they stop bidding on that inventory entirely, ultimately harming long term monetization. What this means is that for any impression to deliver reasonably substantial value to an advertiser, at a minimum:
And the data backs this up too. Overwhelmingly. Advertisers are willing to pay a premium for high viewability impressions. Historically, doubling the viewability results in a 2.4x increase in impression RPM. In other words, the relationship is not linear. For example, if a publisher sells 20,000 impressions at 35% viewability for $1.00 RPM totaling $20, then 10,000 impressions at 70% viewability on the same audience segment will usually go for $2.40 RPM totaling $24. Ultimately, increased viewability results in substantially more revenue.
Only a few major ad buying platforms automatically scale bids on engagement. If the advertiser considers a 100% viewability impression is worth $10, that platform will consider bidding on a 70% viewability impression at $7, or a 30% viewability impression at $3, and so on. Instead, most major buying platforms don’t have automatic engagement scaling, and they require the bidder to set up different line items at different engagement thresholds, so most don’t do that at all. Instead, it’s common for advertisers to pick a threshold (60%, 70%, or 80% viewability), and only bid on inventory that consistently maintains that threshold. The result is that higher viewability impressions have substantially more bid pressure than low viewability impressions. Instead of bidding at half rate for half the viewability, they don’t bid for half viewability at all.
With these concepts in mind, we’ve found many publishers commit blunders that result in damaging their ad accounts, and long term monetization, often irreparably. Tests are usually performed incorrectly, resulting in meaningless or incorrect conclusions. Here are some things to keep in mind when working out these strategies.
Dumb refreshes are those which blindly refresh inventory, usually based on some time interval. Most publishers who try this typically run their dumb refresh at 10-180 seconds. Dumb refreshes do not deliver value to advertisers, and this behavior results in punishment via the feedback loop described above. Many publishers don’t even realize they’ve done anything wrong.
One publisher came to us asking for advice after they had set a dumb refresh down to every 10 seconds, with total disregard for engagement. They tripled their impressions overnight, but their ad rates fell by over 70% in a very short period, resulting in a net loss. Even worse, some of the bidders caught on within a month or so, considered the refresh abusive, and banned the publisher’s ad accounts, worsening their revenue even more. After all, some bidders prohibit refreshes wholesale, and most prohibit abusive refreshes (anything under 30 seconds). Today, that publisher is out of business.
Another common pitfall we’ve seen with refresh strategies is when the publisher sets their refreshes without telling their ad optimization engineers, and then is puzzled why impressions and discrepancies went up while revenue didn’t move (or even goes down). This is usually found out afterward when a publisher tries to write their own refresh strategy and called GPT’s refresh function directly without knowing the full extent of what they’re doing.
What happens here is that header bidding uses key-value pairs (KVPs) to pass bid information up into Google Ad Manager, and by just calling a GPT refresh, the KVPs are not reset appropriately for subsequent impressions. The result is usually either no bid is set, or a bid that has already been used is set. The platform you’re using for header bidding should have their own refresh function that takes are of all of this. Use that function instead.
Another common pitfall in ad buying behavior is that when a publisher makes significant volumes of requests, and the bidder loses, various upstream demand sources stop responding to bid requests. In effect, they’ve determined that it’s cheaper to ignore a publisher who makes excessive bid requests that can’t be won, or are virtually guaranteed not to render. This comes in multiple forms. Instead of disabling the unit properly, we’ve seen publishers hide or remove the ad divs of units from the page. Removing the div does not stop the auction from happening, and any platform that does wait to see what divs are on page will undermonetize as it waits too long even to start the auction. In both cases, the long term effects are the same — reduced monetization.
One common technique frequently used to run up impressions is short-form content — that is splitting up an article, slideshow, top list, or quiz into multiple very small pages. These are sometimes implemented as entirely different pages and sometimes implemented via a single-page-app or other AJAX framework, such that only a portion of the page is refreshed when the visitor goes to the next element in the list or slideshow. Presumably, these publishers expect to get more impressions and run up revenue. But with short-form content, the visitor is typically able to completely consume that short tidbit of content long before the ads can be engaged with. Sometimes the visitor can consume the content even before the ads can finish loading. This is an extremely low-value impression with little or no engagement, and again, in the feedback loop advertisers use for buying, ad rates fall.
In some cases, premium demand sources will review the site for short-form content and reject the publisher’s account application. Some prohibit their ads from being used on short-form content entirely. If the policy teams don’t find out, the advertisers still react in the feedback loop as engagement falls.
One typical setup we’ve seen is a leaderboard unit, a right rail, and then a unit below the content. Often, that below-content unit is below-the-fold (BTF). With short-form content, the user typically does not scroll at all. As they go to the next page in the slideshow or list, BTF units are refreshed without being seen. We’ve seen inventory like this that has single-digit viewability, and this unviewed demand has negligible value. Advertisers know it’s low value, so they bid accordingly.
Even worse, the primary type of advertiser that is still able to monetize these impressions is malvertisers who abuse popups or mobile redirects. As normal advertisers drop out of the auction or bid lower and lower, malvertisers are typically the only ones who can still successfully extract value from impressions that are virtually guaranteed to go unseen. This is because it doesn’t matter whether their malware impression is viewable — mobile redirects and illicit popups only have to load once anywhere on page.
Excessive auctions that result in low win rates reduce overall monetization. An example is a slideshow with a few units on page, and on each slide, the auction fires again. Short-form content is usually consumable by a visitor faster than an auction can fire and render all ads. This results in poor monetization, as upstream demand sources stop responding to excessive bid requests that have low win rates. With some bidders, their tech cannot handle multiple concurrent auctions. If one auction is fired while another is still running, those bidders are excluded or may even error out for the remainder of the pageview, until the ad stack is reset on an entirely new pageview.
For this reason, our platform is set to rarely re-auction in under 30 seconds, and never re-auction in under 10 seconds, outside of full page refreshes. Excessive auctions reduce overall monetization.
Another common blunder is interstitials in short-form content. For example, in a top 10 list, additional slides are inserted every 3-5 pages that only have ads on those pages. The visitors usually realize it’s just an ad, or that the ad is taking long to load, and their finger or mouse is already over the “next” button, so they go to the next slide. Advertisers take this back out on the publisher as the performance falls, and this technique usually results in net losses.
We frequently see publishers using multivariate tests of different ad tech platforms. The issue here is the refresh strategies are also often very different. When set up improperly, the feedback loop described above can easily bleed stats from one side of the test to the other. For example, if one ad tech platform is running a dumb refresh at 10 seconds, and the other is running no refresh at all, the platform running the dumb refresh will have performance artificially overstated while the platform with no refresh will have performance artificially understated. This is because many advertisers use the domain at least as a partial indicator for performance, regardless of which ad platform is being used. When comparing ad tech platforms via multivariate testing, try to use the same or similar refresh strategies across each ad tech platform.
Ad tags and placement IDs (PIDs) are used to differentiate inventory segments to advertisers. When a publisher re-uses the same PIDs or ad tags for two different refresh (or lazy/SPA) strategies, bidders cannot properly differentiate that inventory. Because the performance profile of those strategies is different, publishers should use different ad tags and PIDs. Using the same PIDs and/or ad tags fails to isolate variables in the multivariate test, and will bleed performance from one side of the test to the other.
Competitive intelligence is incredibly important in keeping up with other publishers. However, it’s important not to get caught up in monkey-see-monkey-do. This is for many reasons:
Talk with your adops engineering for the best advice when looking to implement a strategy someone else appears to be using.
Smart refreshes are different from dumb refreshes. Unlike dumb refreshes, smart refreshes only refresh under prime engagement conditions described above. Many of our bidders have reached out to us directly because we had them blocked out on smart refresh inventory due to contract clauses that prohibit refreshes. They wanted to participate in smart refreshed inventory as they realize it delivers substantial value to everyone in the ad chain. The rationale behind a smart refresh is basically that the visitor had a solid chance to interact with this ad impression, wasn’t interested, but maybe interested in something else. Most of our publishers get 15-40% boosts in sustained and long term session RPM with proper smart refresh strategies.
In other words, dumb refreshes can lower monetization by 20% vs. no refresh, while smart refreshes can raise monetization by 15-40%.
Optimal ad setups for short-form content usually start with SPA loading of the content slide. The rest of the page then uses smart refreshes while only the content slide changes. What this does is make sure every ad impression gets a reasonable chance of engagement before getting refreshed.
David Loschiavo is the Chief Product Officer of MonetizeMore. He believes artificial intelligence & machine learning, coupled with technology available to everyone, will change the world for the better and forever.
Here’s the course that 300+ pubs used to scale their ad revenue.
Paid to Publishers
Ad Requests Monthly