A Modern Approach to Performance Monitoring

Cliff Crocker discusses best practices for measuring what matters and applying an understandable methodology that achieves what we are all after: happier users.

Raiders of the Fast Start: Frontend Performance Archeology There are a lot of books, articles, and online tutorials out there with fantastic advice on how to make your websites performant. It all seems easy in theory, but applying best practices to real-world code is anything but straightforward. Diagnosing and fixing frontend performance issues on a large legacy codebase is like being an archaeologist excavating the remains of a lost civilization. You don’t know what you will find until you start digging! Pick up your trowels and come along with Etsy’s Frontend Systems team as we become archaeologists digging into frontend performance on our large, legacy mobile codebase. I’ll share real-life lessons you can use to guide your own excavations into legacy code: What tools and metrics we used to diagnose issues and track progress. How we went beyond server-driven best practices to focus on the client. Which fixes successfully increased conversion, and which didn’t. Our work, like all good archaeology, went beyond artifacts and unearthed new insights into our culture. We at Etsy pride ourselves on our culture of performance, but, like all cultures, it needs to adapt and reinvent itself to account for changes to the landscape. Based on what we’ve learned, we are making the case for a new, organization-wide, frontend-focused performance culture that will solve the problems we face today.

For many years we have concentrated on back-end and network latency and ignored the processing time on the user device. Today, we spent most time on small mobile devices, compared to laptops they’re underpowered and web performance suffers. While handheld devices get more powerful, web pages get more and more complex. Especially the usage of javascript libraries and css framworks is very computational expensive. Based on data from real users, we quantify the relative importance of network and device for web performance. We also benchmark mobile devices and correlate their power to the web performance they achieve.

This document discusses using service workers and other front-end techniques to create a secure and optimal site. It describes how service workers can be used to control third-party content, such as by implementing client reputation strategies to block requests from untrusted sources. Examples are given of how service workers could maintain counters to throttle requests to third-party domains that exceed timeout thresholds, and serve cached or error responses when thresholds are exceeded. The document also discusses how service workers could be leveraged for offline analytics reporting and metric monitoring to reduce risks compared to traditional third-party JavaScript techniques.

Increasing Control with Property Manager by Steve Lerner Senior Member of Technical Staff, Network Engineering, eBay & Jay Sikkeland, Senior Technical Project Manager, Akamai Technologies Property Manager, Akamai's next generation configuration tool, enables engineers a new level of control and visibility for Akamai configurations. Steve Lerner, Sr. Member of Technical Staff from eBay Network Engineering, will demonstrate advanced techniques available in Property Manager designed for a new level of use-cases for Content Delivery Network monitoring and control. He will also demonstrate how key Property Manager settings and Akamai services impact eBay's own metrics and performance. Akamai Edge is the premier event for Internet innovators, tech professionals and online business pioneers who together are forging a Faster Forward World. At Edge, the architects, experts and implementers of the most innovative global online businesses gather face-to-face for an invaluable three days of sharing, learning and together pushing the limits of the Faster Forward World. Learn more at: http://www.akamai.com/edge

Improvements to user experience translate directly to real business metrics and the bottom line. To guide the business to making wise choices on user experience, you need an accurate picture of site performance for real users. In this talk, Steve Lerner will describe how eBay’s performance monitoring strategy has evolved, how the insights gained from real user monitoring have impacted eBay’s business, and some of the considerations that have shaped their in house implementation of Real User Monitoring to serve eBay’s massive global scale. See Steve Lerner's Edge Presentation: http://www.akamai.com/html/custconf/edgetv-commerce.html#real-user-monitoring The Akamai Edge Conference is a gathering of the industry revolutionaries who are committed to creating leading edge experiences, realizing the full potential of what is possible in a Faster Forward World. From customer innovation stories, industry panels, technical labs, partner and government forums to Web security and developers' tracks, there’s something for everyone at Edge 2013. Learn more at http://www.akamai.com/edge

The document discusses Selendroid, a tool for automating tests on mobile web and native Android applications. It begins with an overview of Selenium and the need for mobile test automation. Selendroid is introduced as an open source tool that allows controlling Android devices and applications using the WebDriver protocol. It supports testing native and hybrid mobile applications as well as mobile web. Key features highlighted include compatibility with the JSON wire protocol, no app modification requirement, and support for gestures, grid infrastructure and an inspector tool.

Improving user experience by monitoring real user measurements data. Presented at JS-Lovers Bangalore Meetup 20th Jan 2019

Making Single Page (SPA) Faster was a presentation done at Velocity NY 2016 It covers 3 main points: - selecting the right framework (performance oriented) - best practices and optimizations - monitoring

Slides from talk on Frontend Performance Engineering delivered to Velocity 2009 by David Wei and Changhao Jiang

This document discusses re-using WebDriver-based tests for client-side performance analysis (CSPA). It covers the basics of CSPA, when to initiate CSPA, how CSPA relates to WebDriver tests, tools that can be used for CSPA including BrowserMob Proxy and dynaTrace, and examples of online services and desktop tools. References are provided for further information on CSPA and tools like YSlow, PageSpeed, GTmetrix and webpagetest.

If you have not heard of service workers you must attend this session. Service Workers encompass new browser capabilities, along with shiny new version of AJAX called Fetch. If you have every wanted your web applications to experience many native application features, such as push notifications, service workers is the gateway to your happiness. Have you felt confused by application cache and going offline? Well service workers enable offline experiences in a much cleaner way. But that is not all! If you want to see some of the cool new, advanced web platform features that you will actually use come to this session! https://love2dev.com/blog/what-is-a-service-worker/

Metrics are everywhere! We’ve done a great job of keeping pace with measuring the output of our applications, but how are we doing with measuring what really matters? This talk will explore the various metrics available to application owners today, highlight what’s coming tomorrow and level-set on the relative importance as it relates to the user experience.

Images have a high correlation to page load time. Optimizing image delivery through compression alone is a daunting task. Using HTTP2's superpowers, we can optimize images to ship faster, increasing the perceived performance and initiating users' emotional responses to visuals earlier. HTTP2-powered image delivery leads to lower bounce rates and higher conversions.

This document discusses the browser performance analysis tool dynaTrace. It provides an overview of dynaTrace's capabilities such as cross-browser diagnostics, code-level visibility, and deep JavaScript and DOM tracing. It also covers key performance indicators (KPIs) like load time, resource usage, and network connections that dynaTrace measures. Best practices for improving performance, such as browser caching, network optimization, JavaScript handling and server-side performance are outlined. The document aims to explain why and how dynaTrace can help users find and address web performance issues.

The document discusses strategies for loading third-party scripts asynchronously to improve page load performance. It notes that the frontend accounts for 80-90% of end user response time and recommends loading scripts asynchronously using techniques like async, defer, and loading scripts at the bottom of the page. It also discusses tools for monitoring performance when third-party scripts are blocked.

This document discusses various metrics for measuring website performance and user experience. It outlines different types of metrics including: - Network metrics like DNS resolution, TCP connection times, and time to first byte. - Browser metrics like start render time, DOM loading/ready times, and page load times. - Resource-level metrics obtained from the Resource Timing API like individual asset load times and response sizes. - User-centric metrics like Speed Index, time to visible content, and metrics for single-page applications without traditional page loads. It emphasizes the importance of measuring real user monitoring data alongside synthetic tests, and looking at higher percentiles rather than just averages due to variability in user environments and network conditions

This document discusses various metrics for measuring website performance. It begins by noting that there are many metrics to consider and no single metric tells the whole story. It then discusses several key metrics for measuring different aspects of performance, including: - Front-end metrics like start render, DOM loading/ready, and page load that can isolate front-end from back-end performance. - Network metrics like DNS and TCP timings that provide insight into connectivity issues. - Resource timing metrics that measure individual assets to understand impacts of third parties and CDNs. - User timing metrics like measuring above-the-fold content that capture user experience. It emphasizes the importance of considering real user monitoring data alongside

Integrating content delivery networks into your application infrastructure can offer many benefits, including major performance improvements for your applications. So understanding how CDNs perform — especially for your specific use cases — is vital. However, testing for measurement is complicated and nuanced, and results in metric overload and confusion. It's becoming increasingly important to understand measurement techniques, what they're telling you, and how to apply them to your actual content. In this session, we'll examine the challenges around measuring CDN performance and focus on the different methods for measurement. We'll discuss what to measure, important metrics to focus on, and different ways that numbers may mislead you. More specifically, we'll cover: Different techniques for measuring CDN performance Differentiating between network footprint and object delivery performance Choosing the right content to test Core metrics to focus on and how each impacts real traffic Understanding cache hit ratio, why it can be misleading, and how to measure for it

Not surprisingly, there’s no one-size-fits-all performance metric (though life would be simpler if there were). Different metrics will give you different critical insights into whether or not your pages are delivering the results you want — both from your end user’s perspective and ultimately from your organization’s perspective. Join Tammy Everts, and walk through various metrics that answer performance questions from multiple perspectives. You’ll walk away with a better understanding of your options, as well as a clear understanding of how to choose the right metric for the right audience.

RUM and synthetic monitoring each provide valuable but different performance data. RUM captures real user behavior but numbers vary greatly depending on user environments, while synthetic provides consistent baseline data but doesn't reflect real users. Both data sets are needed to understand a site's true performance across different user scenarios. There is no single performance number, and the right metrics depend on the intended audience and business goals.

This presentation is the first in a series on Improving Rails application performance. This session covers the basic motivations and goals for improving performance, the best way to approach a performance assessment, and a review of the tools and techniques that will yield the best results. Tools covered include: Firebug, yslow, page speed, speed tracer, dom monster, request log analyzer, oink, rack bug, new relic rpm, rails metrics, showslow.org, msfast, webpagetest.org and gtmetrix.org. The upcoming sessions will focus on: Improving sql queries, and active record use Improving general rails/ruby code Improving the front-end And a final presentation will cover how to be a more efficient and effective developer! This series will be compressed into a best of session for the 2010 http://windycityRails.org conference

The document discusses client side performance testing. It defines client side performance as how fast a page loads for a single user on a browser or mobile device. Good client side performance is important for user experience and business metrics like sales. It recommends rules for faster loading websites, and introduces the WebPageTest tool for measuring client side performance metrics from multiple locations. WebPageTest provides waterfall views, filmstrip views, packet captures and reports to analyze page load times and identify optimization opportunities.

As Walmart.com’s former head of Performance and Reliability, Cliff Crocker knows large scale web performance. Now SOASTA’s VP of products, Cliff is pouring his passion and expertise into cloud testing to solve the biggest challenges in mobile and web performance. The holiday rush of mobile and web traffic to your web site has the potential for unprecedented success or spectacular public failure. The world’s leading retailers have turned to the cloud to assure that no matter what load, mobile and web apps will delight customers and protect revenue. Join us as Cliff explores the key criteria for holiday web performance readiness: Closing the gap in front- and back-end web performance and reliability Collecting real user data to define the most realistic test scenarios Preparing properly for the virtual walls of traffic during peak events Leveraging CloudTest technology, as have 6 of 10 leading retailers

My presentation at the Zycko breakfast session... About why your users don't like to wait and why you should care as a site owner. This presentation covers the importance of perception of speed, navigation and how to do proper performance monitoring...

This document discusses the importance of performance testing and provides an introduction to the topic. It notes that performance testing determines how a system behaves under different loads and helps identify bottlenecks. The document outlines why performance testing is important from a user experience perspective, discussing metrics like page load times and the financial costs of poor performance. It then covers various performance testing approaches, targets, levels, and common metrics used to evaluate performance.

Web Performance Internals explained for Developers and others 1. Starting with How Internet Works 2. How Browser Works 3. How to measure Web performance 4. Concluded with tips to Developers and Power users on Improving Web Performance

Why performance testing is important? Introduction to performance testing. Load profiles, metrics Performance testing tools Implementation process Performance testing engineer skills JMeter intro LINKS: About performance testing: http://docplayer.net/29696161-Performance-matters-key-consumer-insights.html http://www.softwaretestingclass.com/what-is-performance-testing/ https://www.blazemeter.com/blog http://revolutionit.com.au/performance-testing-digital-projects-dont-leave-it-to-the-developers/ https://www.youtube.com/embed/61Kkgnx-zF8?list=PLSjEh0z5QH9lKpMO4Nf3buFiP7tt0gTRN Concurrent users calculation: https://blog.xceptance.com/2013/07/26/concurrent-users-the-art-of-calculation/ https://techbeacon.com/how-many-virtual-users-do-i-need-load-testing https://www.webperformance.com/library/tutorials/CalculateNumberOfLoadtestUsers/ Browser performance: https://www.slideshare.net/nicjansma/measuring-real-user-performance-in-the-browser Books for start: “Web Load Testing For Dummies”, Scott Barber with Colin Mason “JMeter Cookbook”, Bayo Erinle

The document provides an overview of Daniel Austin's Web Performance Boot Camp. The class aims to (1) provide an understanding of web performance, (2) empower attendees to identify and resolve performance issues, and (3) demonstrate common performance tools. The class covers topics such as the impact of performance on business, definitions of performance, statistical analysis, queuing theory, the OSI model, and the MPPC model for analyzing the multiple components that determine overall web performance. Attendees will learn tools like Excel, web testing tools, browser debugging tools, and optional tools like R and Mathematica.

Integrating content delivery networks into your application infrastructure can offer many benefits, including major performance improvements for your applications. So understanding how CDNs perform — especially for your specific use cases — is vital. However, testing for measurement is complicated and nuanced, and can result in metric overload and confusion. It’s becoming increasingly important to understand measurement techniques, what they’re telling you, and how to apply them to your actual content.

ThousandEyes provides network intelligence and monitoring of web performance. It offers different test types - HTTP server tests measure server response times, page load tests measure loading of full web pages in a browser, and web transaction tests measure performance of specific user interactions on a site. The tests provide metrics on response times, throughput, errors and performance of individual page components from different network locations and internet providers. The document recommends tips for optimizing web transactions such as adjusting timeouts, configuring start/stop steps, using XPath locators, and inserting wait conditions. It demonstrates creating and running page load, HTTP server and web transaction tests to monitor web performance.

As a Tester you need to level up. You can do more than functional verification or reporting Response Time In my Performance Clinic Workshops I show you real life exampls on why Applications fail and what you can do to find these problems when you are testing these applications. I am using Free Tools for all of these excercises - especially Dynatrace which gives full End-to-End Visibility (Browser to Database). You can test and download Dynatrace for Free @ http://bit.ly/atd2014challenge

This document discusses modern browser APIs that can improve web application performance. It covers Navigation Timing, Resource Timing, and User Timing which provide standardized ways to measure page load times, resource load times, and custom events. Other APIs discussed include the Performance Timeline, Page Visibility, requestAnimationFrame for script animations, High Resolution Time for more precise timestamps, and setImmediate for more efficient script yielding than setTimeout. These browser APIs give developers tools to assess and optimize the performance of their applications.

My slides from DrupalJam 2014... About why users abandon your website and best practices to align content and speed to create a fast user experience, and continue to keep it aligned for every release

This document describes how APNIC measures IPv6 adoption by co-opting hundreds of millions of internet users through online ad campaigns. When an ad loads, it sends a "priming query" to APNIC to get a list of measurement tasks. The tasks involve resolving domain names and fetching URLs to APNIC servers, which log the results. APNIC is able to vary tasks to test different capabilities and collect a massive amount of data to analyze IPv6 usage at scale.

Learn how end users experience your apps and get in-depth understanding of problems affecting real users. Analyze app performance from every aspect.