It's been well established that there is a correlation between fast digital experiences and positive business results. What users experience on a site has a direct bearing on their engagement and buying behaviour and consequently the overall success of the business. Slow page load times can lead to high bounce rates, low NPS and SEO ranking. So now that performance is a priority for a lot of digital teams the next question is, "how fast do i need to be?", and "what is it that is still killing our end users web experience?" The 'what' referring to which of the various page elements - HTML, images, scripts, CSS, video and others, that continue to bloat and slow down web pages. Images and scripts are known to be the heaviest and most problematic performance bottlenecks.
Managing the unpredictability and performance impact of third party scripts is especially difficult because the of the nature of third party content, we're talking about objects that are part of your web experience that are delivered from someone else's infrastructure that is outside of your direct control. The third party content integrated into your site usually serves an important business function, whether that be for marketing analytics, personalization, social engagement, or advertising revenue. That's exactly why HTTP Archive shows that about 27% of sites have between 90% and 99% third party requests! This interesting stat also illustrates how pervasive the associated security and performance concerns are with third party content.
So how can you get a handle on it? Well the key is to have focus on continuous improvement with right tools to give you two things in real time - Visibility & Control over the unpredictability and business impact of problematic page elements so you can manage the risks and mitigate the problems .
Akamai 's intelligent edge platform gives you the power of real user data to both find AND fix performance issues with automated, data-driven performance optimizations. How does it work?
FIND & FIX
Let's put this in the context of real world use cases. On a typical day, let's suppose a large online business has around 25 million user sessions serving more than 1 billion requests including 1st and third party scripts. However their developers struggle with answering the following questions for themselves and their business:
How many scripts do we even have?
The never ending struggle with dynamic insertions of scripts through tags. Visibility is always the first step hence knowing all the scripts running on your pages in real time is critical. Akamai's Aggregate Resource Waterfall view in mPulse allows you to have a high level of visibility into what's happening across all the scripts running on various pages.
Is this script worth it? What happens to my page load and conversion if this script were to perform better ... or worse?
Scripts are building blocks of the customer experience or third party service integrations that serve an important business function. Even so, It's important to evaluate their impact on performance alongside their impact to your business metrics to understand, is this script worth it? Most organizations struggle with quantifying this tradeoff - risking performance impact by keeping a third party service versus possible loss of business value by eliminating it.
Akamai's new Resource Impact Analysis as part of mPulse offers some powerful insights to help inform these trade-off decisions. It allows users to see aggregated real user data over all the user sessions during a chosen time frame showing relative conversion impact score of each page group down to resource level detail. What makes this incredibly powerful is the interactivity. It allows you to model scenarios preview the impact of speeding, slowing or eliminating a certain script on the overall page load and conversion allowing them to make swift decisions and focus on developing new functionality and silencing the debate with marketing and digital teams about the business value of keeping a tag despite its performance impact.
This script is slow right now, is it always this slow?
Once the Resource Impact Analysis view has helped you understand the business impact a problematic page element is having on your page, Aggregate Resource Waterfall can provide insights one level deeper and answer some additional, critical questions for you.
"How often is it slow?" Using a traditional waterfall you're looking at data at single point in time. Because of this you're blind to historical performance of a script or file to help you evaluate if the conditions you're seeing are typical or an outlier. Aggregate Resource Waterfall allows you to have an aggregated view of performance of all resources or an individual third party script over a chosen time frame. It lets you discern how fast, slow, consistent or inconsistent has a third party performed over time so that you can have a mitigation plan based on a more robust data set instead of a one off slowdown. What's also important is this data is reported relative to page timing milestones so you can troubleshoot things like failed data capture from your marketing analytics or gaps in advertising tag placement.
Armed with this information you can decide if you need to tune your application code or if you should take an automated approach with Script Management in Ion, to use the power of real user data to automatically mitigate the impact of poorly performing scripts on the user experience.
You do your best to choose the right partners and scrutinize the code that you allow them to place on your pages but ensuring optimum performance of any embedded third party scripts on hundred percent of the time is essentially out of your control. Akamai strives to give you the tools that put the power in your hands to protect your experience from unexpected failures in case when they happen.
So when it does happen, not only do you need the visibility to know, what the problem is but also a quick way to take action, because every second counts in these matters. That's where Akamai's Ion gives you the power to take action to defer or block the problematic script as you see fit. There will be some cases where you'll want to intervene manually but in others how can you build resilience into your strategy to avoid single points of failure from popping up and plaguing site performance?
How can I proactively avoid SPOFs without fire fighting every time?
Although manual intervention is effective you'll want to take action must faster to really minimize the impact in cases where it's safe to do so. For this Ion will leverage the power of performance data and machine learning to mitigate SPOFs on your behalf. Using real user data to track the performance of first and third party scripts apply automated policy based mitigations that defer or block scripts that aren't meeting your standards for performance. Keeping that end user experience as top priority the Script Management Policy Tester allows you to preview the impact of the policies on page rendering in the browser, so you can see the result of the action to defer or block exactly as your visitors would.
Akamai is the only platform that can both find and fix issues with 1st and third party performance by uncovering blind spots, characterizing problematic resources over time, and automatically taking action with intelligent, adaptive optimizations based on machine learning.
Learn more and try Akamai's mPulse Lite and Ion HERE. For a deeper dive in Ion Script Management and an overview of what's new across Akamai's DevOps, Web Performance, and Security portfolio register for this WEBINAR.