One of the biggest concerns that publishers have about any new product is latency. Publishers are rightfully wary of any product that will add more code to a page and risk slowing down loading times. Reader attention is measured in seconds, and when your page loads slowly, your readers bounce. It goes without saying that user experience and fast loading times should be preserved at all costs.
We built //Signal specifically to address those concerns. //Signal creates no added latency, which ensures that publishers can rest easy about engineering concerns, and that readers are given the positive site experience they deserve. //Signal doesn’t slow your site down. It doesn’t hurt your advertising performance. And it definitely does make you more money.
This week, we’re taking a dive into latency. Formerly an issue with legacy ad refresh products, //Signal is built to be lightweight, easy to implement, and focused on reducing page load times.
How it’s so fast (Page load time / Latency):
The way it’s built
//Signal is delivered through //Connect, which is our ultra-lightweight, single-tag delivery system. In order to guarantee timing efficiency, every //Connect container is precompiled. It then goes through the Google Closure Compiler, which further minimizes the size of the tag. In the same way, our script includes only necessary features in order to minimize dead code. Once the tag is completed, it is further compressed using gzip, taking the tag from an average of 57kb to 16kb.
Importantly, this also prevents any excess engineering work. All that’s required is copying and pasting a single tag. And because //Connect is a unified system, it’s updated automatically, freeing up your resources for other projects.
The way it’s delivered
Once the //Signal tag has been precompiled and compressed via //Connect, we use Amazon Cloudfront to deliver our //Connect content to publishers. This ultra-fast cloud infrastructure has available endpoints in North California, London, and Frankfurt, which helps prevent added latency.
The way it loads
//Signal uses the async and defer attributes to load asynchronously. This means the page is not stopped from parsing while the tag loads its content, resulting in much better load times and user experience.
Browsers that support the defer attribute will execute the //Connect script (inside of which //Signal is contained) after the document has finished parsing. This means that the script will be downloaded in parallel (asynchronously) with the page, but will be queued to execute shortly after the page is parsed.
The async attribute is very similar to defer, and is used to ensure asynchronous loading is supported across all browsers—for instance, defer is not supported on Opera—and that //Connect retains its lightweight loading structure in cases when defer is not available.
Just like the defer attribute, async fetches the //Connect script asynchronously. However, it will instead briefly interrupt the parsing of the document. In cases in which both async and defer are available, defer takes precedence.
What this means is that in either case //Signal won’t stop the page in question from loading, and it won’t add latency while a user is busy interacting with your content. It’s a streamlined process that’s focused on user experience.
The way it collects data
Every metrics call that //Connect makes is executed when the user is not actively engaged with the page. Instead, //Connect asynchronously transfers a small amount of data over HTTP to a web server. This prevents slowdown during user sessions, and allows //Signal to go unnoticed on the page.
The way it activates
//Signal requires only a single pixel to target all the ad placements on a page, instead of requiring a pixel for every zone. This means that it’s only making a single browser call, rather than multiple calls multiple times over the course of a session. Again, this means that //Signal doesn’t overwhelm browsers, thereby preventing annoying page slowdown.
The bottom line
If you’re worried about latency, don’t be.
In fact, the time to load //Connect content (such as //Signal) goes from a minimum of 0.00012 seconds to a maximum of 0.07627 seconds, with an average of 0.00208 seconds. That’s fast enough to be unnoticeable by users, and yet it’s enough time to deliver a product that can give you 5x the yield and 3x the fill of header bidding, while also improving your viewability scores. That’s a lot of revenue delivered through a tiny piece of code.
If you’re interested, Sovrn publishers can use //Signal for free. It’s as easy as creating an ad tag. Send us a message, and we’ll show you how.