Testing Website Performance Using Playwright

This guide looks at the various ways web developers and testers can use @playwright/test framework to measure website performance. It covers topics such as setting up Playwright, writing Playwright tests, and interpreting and analyzing the results.
  1. Why Performance Matters: A Competitive Differentiator
    1. Measuring Performance: Web Performance APIs
      1. Navigation and Resource Timing API
        1. Paint Timing API (first-paint and first-contentful-paint)
          1. Largest Contentful Paint API (largest-contentful-paint)
            1. Layout Instability API (layout-shift)
              1. Long Task API (longtask)
              2. Chrome DevTools for Performance
                1. Additional Performance Libraries
                  1. Conclusion

                    Why Performance Matters: A Competitive Differentiator

                    In today's fast-paced digital world, website performance is a critical aspect of user experience. With users' attention spans shrinking and competition increasing, ensuring your website performs optimally is a key differentiator. The BBC discovered that every extra second a page took to load led to 10% of users leaving the page source. As a result, it's essential for QA engineers to measure website performance and make necessary optimizations.

                    Measuring Performance: Web Performance APIs

                    Several Web Performance APIs allow developers and testers to measure website performance. These APIs provide insights into various performance metrics, enabling you to understand how your website performs and identify areas for improvement.

                    The Navigation and Resource Timing API provides detailed information about the time it takes for various resources to load, such as HTML, CSS, JavaScript, and images. This information can be used to optimize your website's loading process and improve overall performance.

                    import { test } from '@playwright/test';
                    test('measure navigation and resource timing', async ({ page }) => {
                      await page.goto('https://ray.run/');
                      const performanceTiming = await page.evaluate(() => performance.getEntriesByType('navigation')[0]);
                      console.log('Performance Timing:', performanceTiming);

                    Paint Timing API (first-paint and first-contentful-paint)

                    The Paint Timing API measures when the browser first starts to render content on the screen (first-paint) and when it renders the first bit of content from the DOM (first-contentful-paint). These metrics can help you understand how quickly your website becomes visually usable for the user.

                    import { test } from '@playwright/test';
                    test('measure paint timing', async ({ page }) => {
                      await page.goto('https://ray.run/');
                      const paintMetrics = await page.evaluate(() => performance.getEntriesByType('paint'));
                      console.log('Paint Metrics:', paintMetrics);

                    Largest Contentful Paint API (largest-contentful-paint)

                    The Largest Contentful Paint (LCP) API measures when the largest element within the viewport becomes visible. This metric is important for understanding the perceived loading speed of your website, as users typically focus on the largest content elements.

                    import { test } from '@playwright/test';
                    test('measure largest contentful paint', async ({ page }) => {
                      await page.goto('https://ray.run/');
                      const lcpObserver = new PerformanceObserver((entryList) => {
                        const lcp = entryList.getEntries()[0];
                        console.log('LCP:', lcp);
                      lcpObserver.observe({ type: 'largest-contentful-paint', buffered: true });

                    Layout Instability API (layout-shift)

                    The Layout Instability API measures layout shifts, which occur when elements on a page move unexpectedly due to late-loading resources or dynamic content changes. High layout shift scores can lead to poor user experiences, as content may become unreadable or difficult to interact with.

                    import { test } from '@playwright/test';
                    test('measure layout shift', async ({ page }) => {
                      await page.goto('https://ray.run/');
                      const clsObserver = new PerformanceObserver((entryList) => {
                        const cls = entryList.getEntries()[0];
                        console.log('CLS:', cls);
                      clsObserver.observe({ type: 'layout-shift', buffered: true });

                    Long Task API (longtask)

                    The Long Task API helps identify tasks that take a long time to execute, causing the main thread to become blocked and leading to unresponsive web pages. By identifying and optimizing long tasks, you can improve the responsiveness of your website.

                    import { test } from '@playwright/test';
                    test('measure long tasks', async ({ page }) => {
                      await page.goto('https://ray.run/');
                      const longTaskObserver = new PerformanceObserver((entryList) => {
                        const longTasks = entryList.getEntries();
                        console.log('Long Tasks:', longTasks);
                      longTaskObserver.observe({ type: 'longtask' });

                    Chrome DevTools for Performance

                    In addition to Web Performance APIs, Chrome DevTools provides a comprehensive suite of tools for analyzing website performance. These tools can help you identify bottlenecks, measure load times, and visualize rendering performance. By combining the power of Playwright with Chrome DevTools, you can gain a deeper understanding of your website's performance and make data-driven optimizations.

                    Additional Performance Libraries

                    There are several third-party libraries available that can help you measure and improve website performance. Some popular libraries include:

                    • Lighthouse: An open-source tool for improving the quality of web pages, providing performance audits and recommendations.
                    • WebPageTest: A web performance testing tool that allows you to run tests on real browsers and devices, providing detailed performance reports and optimization suggestions.
                    • SpeedCurve: A performance monitoring tool that provides real-time performance data and helps you track the impact of optimizations over time.

                    By integrating these libraries with your Playwright tests, you can gain even more insights into your website's performance and make informed decisions about optimizations.


                    Measuring website performance is crucial for ensuring a positive user experience and maintaining a competitive edge. By leveraging the power of Playwright and Web Performance APIs, you can accurately measure performance metrics, identify bottlenecks, and make data-driven optimizations. With a combination of Chrome DevTools and third-party libraries, you can further enhance your performance testing capabilities and ensure your website remains fast, responsive, and user-friendly.

                    Thank you!
                    Was this helpful?

                    Now check your email!

                    To complete the signup, click the confirmation link in your inbox.

                    Subscribe to newsletter

                    You will receive a weekly email with the latest posts and QA jobs.

                    AboutQuestionsDiscord ForumBrowser ExtensionTagsQA Jobs

                    Rayrun is a community for QA engineers. I am constantly looking for new ways to add value to people learning Playwright and other browser automation frameworks. If you have feedback, email luc@ray.run.