How to avoid chaining critical requests.

9 Jul 2024 | 7 min read
How to avoid chaining critical requests.

Understanding Chaining Critical Requests

Chaining critical requests happens when your website makes several dependent network requests to load a page. Each request relies on the one before it, like a chain. This slows down your site because the browser has to wait for each link in the chain to finish before it can move on.

What are Critical Requests?

Critical requests are those that your website needs to load first to display the main content. These can be files like CSS, JavaScript, and images. If these files load slowly, your webpage takes longer to appear to users.

How Chaining Happens

Imagine you have a web page. First, the browser loads the HTML. The HTML then asks for a CSS file. Once the CSS is loaded, it asks for a font file. After the font file, the CSS needs to load images. This creates a chain: HTML → CSS → Font → Images. Each step depends on the one before it. This can cause delays.

Impact of Chaining Critical Requests on Core Web Vitals

Chaining critical requests can slow down your website and hurt your Core Web Vitals. These vitals are important measures of your website’s performance. They include Largest Contentful Paint (LCP), First Input Delay (FID), and Cumulative Layout Shift (CLS). Let’s look at how chaining critical requests affects each of these.

Largest Contentful Paint (LCP)

LCP measures how long it takes for the main content of a page to load. If you have a chain of critical requests, each one depends on the previous one. This means your main content takes longer to load. For example, if your HTML needs to load a CSS file, and the CSS needs to load a font, and then an image, this chain slows down the LCP. Users will have to wait longer to see the main part of your page, which can be frustrating.

First Input Delay (FID)

FID measures how long it takes for your page to respond when a user first tries to interact with it. While FID mainly looks at how quickly your page reacts to user actions, chaining critical requests can indirectly slow it down. If the browser is busy handling a long chain of requests, it might not respond quickly to user input. This can make your site feel sluggish and unresponsive.

Cumulative Layout Shift (CLS)

CLS measures how much your page layout moves around while loading. If critical resources load slowly because of chaining, parts of your page might jump around as they finally appear. For instance, if images or fonts load late, they can push other content around, causing layout shifts. This can make your page look unstable and annoy users.


CSS and Fonts: Your HTML file loads a CSS file, which then loads a font file. This creates a chain.

JavaScript and Images: Your HTML file loads a JavaScript file, which then loads an image. This also creates a chain.

Third-Party Scripts: Widgets or ads from other servers can add more chains of critical requests.

How to Avoid Chaining Critical Requests

Avoiding chaining critical requests helps your website load faster and perform better. Here are step-by-step strategies to break these chains and improve your Core Web Vitals.

Step 1: Minimize Dependencies

Reducing the number of dependencies is the first step to avoid chaining critical requests. When your HTML file depends on several other files to load, it creates a chain of requests. Here’s how to minimize these dependencies:

  • Combine Files: Combine your CSS and JavaScript files. Instead of loading multiple CSS files, combine them into one. Do the same for JavaScript files. This reduces the number of requests the browser has to make.
  • Inline Critical CSS: Inline the most critical CSS directly in the HTML file. This means putting the CSS code needed to style the above-the-fold content directly in the HTML file. This reduces the need for an extra request to load CSS.
  • Remove Unused Code: Remove any unused CSS and JavaScript. This makes your files smaller and reduces the number of dependencies. Tools like PurifyCSS can help you identify and remove unused CSS.
  • Use Conditional Loading: Load certain files only when necessary. For example, if a particular JavaScript file is only needed on certain pages, load it conditionally. This avoids making unnecessary requests on pages where the file isn’t needed.

By minimizing dependencies, you reduce the number of chained requests, helping your page load faster.

Step 2: Preload Key Resources

Preloading key resources ensures that the most important files are loaded as soon as possible. This helps break the chain of critical requests. Here’s how to do it:

Use <link rel=”preload”>: Preload your critical CSS, JavaScript, and fonts. This tells the browser to load these resources as soon as it encounters the HTML file.


<link rel="preload" href="critical.css" as="style">

<link rel="preload" href="critical.js" as="script">

<link rel="preload" href="font.woff2" as="font" type="font/woff2" crossorigin="anonymous">

Prioritize Key Resources: Identify which resources are critical for the initial rendering of your page. Preload these resources to ensure they are available as soon as the browser starts loading the page.

Optimize Fonts: Preload fonts to avoid delays caused by font loading. Use font-display: swap in your CSS to ensure text remains visible during font loading.


@font-face {
font-family: 'MyFont';
src: url('font.woff2') format('woff2');
font-display: swap;


By preloading key resources, you ensure that the most important files are loaded quickly, reducing the impact of chained requests.

Step 3: Optimize Resource Loading

Optimizing how your resources are loaded can significantly reduce the time it takes for your page to load. Here’s how to optimize resource loading:

Compress Files: Use gzip or Brotli compression to reduce the size of your CSS, JavaScript, and HTML files. Smaller files load faster, reducing the time spent on each request.

Asynchronous Loading: Load non-critical JavaScript files asynchronously. This means the browser can continue loading other resources while the JavaScript file loads in the background.

<script src="non-critical.js" async></script>

Defer Non-Critical JavaScript: Defer the loading of JavaScript files that are not needed immediately. This prevents them from blocking the rendering of your page.

<script src="non-critical.js" defer></script>

Lazy Load Images and Videos: Use lazy loading for images and videos to load them only when they come into the viewport. This reduces the initial load time.

<img src="image.jpg" loading="lazy" alt="Lazy Loaded Image">

By optimizing resource loading, you ensure that your critical resources are loaded quickly and efficiently, improving your page’s performance.

Step 4: Optimize Server Response Times

Fast server response times are crucial for reducing the time it takes to load your page. Here’s how to optimize your server response times:

Use a Content Delivery Network (CDN): A CDN distributes your content across multiple servers worldwide. This means users can download your files from a server close to them, reducing load times.

Cache Static Resources: Use caching to store static resources like CSS, JavaScript, and images. This reduces the number of requests to the server.

<meta http-equiv="Cache-Control" content="public, max-age=31536000">

Optimize Server Performance: Ensure your server is optimized for performance. Use server-side caching, optimize database queries, and reduce server processing time.

Monitor Server Response Times: Use tools like Google PageSpeed Insights or WebPageTest to monitor your server response times. Identify and fix any bottlenecks.

By optimizing server response times, you ensure that your critical resources are delivered quickly, reducing the impact of chained requests.

Step 5: Use Best Practices for Web Development

Following best practices for web development helps you avoid chaining critical requests and ensures your page loads quickly. Here are some best practices to follow:

  • Reduce Redirects: Avoid unnecessary redirects. Each redirect creates an additional request, slowing down your page.
  • Use HTTP/2: HTTP/2 allows multiple requests to be sent over a single connection, reducing the impact of chained requests.
  • Optimize Third-Party Scripts: Third-party scripts like ads and widgets can create additional chained requests. Optimize these scripts or consider removing unnecessary ones.
  • Regular Audits: Regularly audit your website for performance. Use tools like Lighthouse, PageSpeed Insights, and WebPageTest to identify and fix performance issues.

By following these best practices, you can avoid chaining critical requests and ensure your page loads quickly and efficiently.

Avoiding chaining critical requests is key to improving your website’s performance and Core Web Vitals. By minimizing dependencies, preloading key resources, optimizing resource loading, improving server response times, and following best practices, you can ensure your website loads quickly, providing a better experience for your users.

Avoiding chaining critical requests is crucial for improving your website’s performance and user experience. By understanding what chaining critical requests are and their impact on Core Web Vitals, you can take proactive steps to minimize dependencies, preload key resources, optimize resource loading, and improve server response times. Using tools like Google Lighthouse, PageSpeed Insights, WebPageTest, and Chrome DevTools, you can monitor your website’s performance, identify issues, and implement best practices for optimization. These efforts will lead to faster load times, better Core Web Vitals scores, and a more satisfying experience for your users.

Join Our Community:
Subscribe for Updates

Recent Blogs

View All Blogs