Why Your Page Feels Slow (and Hurts Your PageSpeed Score): Render Blocking and Critical CSS Explained

Rijul Rajesh -

When it comes to website performance, speed is everything. A beautifully designed page doesn’t matter if users stare at a blank screen waiting for it to load. The faster your page appears, the better the experience feels. That’s where Critical CSS, inlining, and smart loading strategies like preload and deferring non-critical CSS come in.

This guide breaks down what these techniques mean, how they work, and how you can use tools like Beasties to automate the process in your own projects.

Lets start from the basics and slowly build up to the real stuff.

What Happens When a Page Loads

When a browser loads a web page, it starts from top to bottom. Every time it encounters a <link rel="stylesheet"> tag, it pauses to download and process the CSS before continuing to render the page.

This pause is known as render blocking.

CSS is render blocking by default because the browser needs to know all the styles before it can correctly display any part of the page. If your CSS files are large or hosted on a slow network, users might see nothing or a flash of unstyled content while waiting.

That’s why managing how and when CSS loads is so important.

Understanding Above-the-Fold Content

Before talking about Critical CSS, it helps to understand what “above the fold” means. The phrase comes from newspapers, where the most important headlines appeared on the top half of the front page: the part visible before unfolding the paper.

On a website, above-the-fold content is what a user sees immediately when they land on your page, before scrolling. This might include your logo, navigation bar, and hero section.

If you can make just that portion appear quickly, the page feels responsive and engaging even while the rest of it continues to load in the background.

What Is Critical CSS?

Critical CSS is the CSS required to style the above-the-fold portion of a webpage. Instead of waiting for an external CSS file to load, you place these essential styles directly inside the <head> of your HTML file.

This is called inlining CSS.

When done correctly, the browser can immediately render the visible part of your site without waiting for large CSS files to download. The rest of the styles can be loaded later. This improves key performance metrics like Largest Contentful Paint (LCP), which measures how quickly the main visible content appears.

Why Inlining Works So Well

When the browser encounters inlined CSS, it can apply styles right away since they are already part of the HTML file. This eliminates the delay caused by external CSS files.

By showing styled content instantly, users perceive your site as faster, even if some assets continue to load in the background. This small improvement can make a big difference in overall user satisfaction and SEO.

Avoid Over-Inlining

Inlining too much CSS can backfire. Here’s why:

  • It increases the size of your HTML file, making it slower to download.
  • The browser must parse a bigger document before displaying anything.
  • You lose caching benefits, since inline styles cannot be stored separately.
  • Any CSS change forces a full page reload instead of using cached assets.

The best approach is to inline only what’s absolutely needed for the first view and keep the rest as external stylesheets.

Deferring Non-Critical CSS

Once the essential styles are inlined, you can defer non-critical CSS. This means loading the rest of your styles after the initial render so they don’t block the page.

Here’s one simple method:

<link rel="preload" href="main.css" as="style" onload="this.onload=null;this.rel='stylesheet'">
<noscript><link rel="stylesheet" href="main.css"></noscript>

This tells the browser to start fetching the CSS file early but not apply it until it’s fully downloaded. It ensures your page shows something styled immediately while the rest of the styles load quietly in the background.

The <noscript> tag ensures that users with JavaScript disabled still get the CSS normally.

Preload vs Stylesheet

Let’s quickly compare the two:

Method Description Effect on Rendering
<link rel="stylesheet"> Loads and applies CSS immediately Blocks rendering until CSS is downloaded and parsed
<link rel="preload" as="style"> Starts fetching CSS early but doesn’t apply it yet Does not block rendering; must later change rel to stylesheet manually

By using preload, you give the browser a head start. By combining it with Critical CSS, you get both speed and control.

How Render Blocking Impacts PageSpeed


Render blocking is one of the main causes of poor PageSpeed scores. Google’s PageSpeed Insights often highlights blocking CSS as an issue. When stylesheets block rendering, it delays First Contentful Paint (FCP) and Largest Contentful Paint (LCP), which are key metrics used in Core Web Vitals.

By inlining critical styles and deferring the rest, you reduce render blocking and make the page visually complete much faster.

Automating Critical CSS with Beasties

Manually figuring out which CSS is critical can be tedious. This is where tools like Beasties, Penthouse, or Critical come in. They analyze your pages and automatically extract only the CSS needed for the above-the-fold content.

Let’s walk through a quick, hands-on demo to see how Beasties works.

Step 1: Set Up a Simple Project

Create a new folder and open it in your terminal:

mkdir beasties-demo
cd beasties-demo

Initialize a basic Node project:

npm init -y

Then install Beasties:

npm install beasties

Step 2: Add a Sample HTML and CSS File

Create a dist folder (this is where your HTML lives):

mkdir dist

Now inside dist/, create these two files:

index.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Beasties Demo</title>
    <link rel="stylesheet" href="style.css">
  </head>
  <body>
    <header class="hero">
      <h1>Hello, World!</h1>
      <p>This is a demo to test Critical CSS inlining.</p>
    </header>

    <main>
      <section>
        <h2>More Content Below</h2>
        <p>This content is below the fold and not immediately visible.</p>
      </section>
    </main>
  </body>
</html>

style.css

/* Above the fold styles */
body {
  margin: 0;
  font-family: system-ui, sans-serif;
  background: #f7f9fc;
  color: #333;
}

.hero {
  background: #4f46e5;
  color: white;
  padding: 100px 20px;
  text-align: center;
}

/* Below the fold styles */
main {
  margin-top: 200vh;
  background: #fff;
  padding: 40px;
}

Step 3: Create the Beasties Script

In the root folder (next to package.json), create:

inline-critical.js

import fs from 'fs/promises';
import path from 'path';
import Beasties from 'beasties';

async function inlineCriticalCss() {
  const distDir = './dist';
  const indexPath = path.join(distDir, 'index.html');

  let html = await fs.readFile(indexPath, 'utf-8');

  const beasties = new Beasties({
    path: distDir,
    publicPath: '/',
  });

  const processedHtml = await beasties.process(html);
  await fs.writeFile(indexPath, processedHtml, 'utf-8');

  console.log('✅ Critical CSS inlined successfully!');
}

inlineCriticalCss().catch(console.error);

Add a small script to package.json so you can run it easily:

"scripts": {
  "inline": "node inline-critical.js"
}

Step 4: Run the Script

Run the following command:

npm run inline

Beasties will scan your HTML, detect above-the-fold styles, and inline them directly into the <head> of your HTML file.

You’ll see a success message like:

✅ Critical CSS inlined successfully!

Step 5: Check the Result

Open dist/index.html again. It should now look like this:

<!DOCTYPE html>
<html lang="en" data-beasties-container>
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Beasties Demo</title>
    <style>body{margin:0;font-family:system-ui, sans-serif;background:#f7f9fc;color:#333}.hero{background:#4f46e5;color:white;padding:100px 20px;text-align:center}main{margin-top:200vh;background:#fff;padding:40px}</style>
    <link rel="preload" href="style.css" as="style">
  </head>
  <body>
    <header class="hero">
      <h1>Hello, World!</h1>
      <p>This is a demo to test Critical CSS inlining.</p>
    </header>

    <main>
      <section>
        <h2>More Content Below</h2>
        <p>This content is below the fold and not immediately visible.</p>
      </section>
    </main>
  <link rel="stylesheet" href="style.css"></body>
</html>

Beasties automatically extracted the critical CSS (the styles needed for the hero section) and placed them inside a <style> tag in the head.
It also preloaded the full stylesheet for later use, ensuring the rest of the page loads smoothly.

The result is a page that:

  • Displays above-the-fold content instantly
  • Reduces render-blocking CSS
  • Improves your PageSpeed and Core Web Vitals scores

Balancing Performance and Maintainability

A good performance setup usually follows these principles:

  1. Inline only the essential styles for the first viewport.
  2. Defer or preload non-critical CSS so it doesn’t block rendering.
  3. Avoid duplication, where CSS is both inlined and loaded separately.
  4. Use automation tools like Beasties to make the process easier.

This approach keeps your pages light, fast, and easy to maintain.

Final Thoughts

Web performance isn’t just about passing speed tests. It’s about making the site feel fast to real people. Critical CSS, preload, and deferred styles help you do exactly that.

When used together:

  • Users see something meaningful almost instantly.
  • Search engines detect faster load times.
  • You maintain a clean, efficient workflow.

Speed doesn’t come from doing everything at once. It comes from doing the right things first: showing what matters, loading what’s needed, and deferring the rest.

I’ve been building for FreeDevTools.

A collection of UI/UX-focused tools crafted to simplify workflows, save time, and reduce friction in searching tools/materials.

Any feedback or contributors are welcome!

It’s online, open-source, and ready for anyone to use.

👉 Check it out: FreeDevTools
⭐ Star it on GitHub: freedevtools

Let’s make it even better together.