Render-Blocking Resources: Fix What Delays First Paint
Render-blocking resources are files the browser must deal with before it can draw the page. Chrome's Lighthouse documentation flags scripts in the head without defer or async, and stylesheets whose media matches the device. Seed Light fixes these during a build.

A speed test tells you to eliminate render-blocking resources. It names four files, none of which you recognise, and offers no way to act.
Render-blocking resources sound like a developer problem, and two of the five fixes below are settings anybody can change.
The idea underneath is simple. Some files have to be dealt with before anything appears, and every one of them delays the moment your page becomes visible.
The good news is that the list is short and the fixes are ordered. You do not need to understand everything in the report to make the page faster.
This guide covers what counts as render blocking, why CSS and JavaScript behave differently, the fixes in order of safety, and the one number worth aiming at.
Key Takeaways
- Two kinds get flagged. Scripts in the head with no defer or async, and stylesheets whose media matches the device.
- CSS blocks by default. The browser pauses rendering until it has dealt with files it considers critical.
- Scripts block the parser. Unless they are specifically marked asynchronous or deferred.
- Defer is the safer default. It preserves execution order where async does not.
- Aim at 2.5 seconds. Google's target is Largest Contentful Paint within 2.5 seconds at the 75th percentile of page loads.
What Render-Blocking Resources Are
The browser reads your page from the top. When it meets certain files it stops, fetches them, and only then carries on.
Nothing is drawn during that pause. The visitor is looking at a blank screen, whatever else has already downloaded.
Web.dev describes it plainly. Some resources are deemed so critical that the browser pauses page rendering until it has dealt with them.
Chrome's Lighthouse documentation is more specific about what gets flagged. A script element in the head with no defer or async attribute, and a stylesheet link with no disabled attribute whose media attribute matches the device.
That last detail catches people out. A stylesheet with media set to all counts as render blocking, and media set to all is the default.
Which means almost every stylesheet on almost every site qualifies. The question is not whether you have any, it is how many and how large.
A single small stylesheet is a reasonable thing to block on. Six stylesheets from six plugins is where the delay becomes visible to a person.

Why CSS and JavaScript Behave Differently
They block for different reasons. That is why the fixes differ.
CSS is render blocking by default. The browser will not draw content it may have to restyle immediately afterwards, so it waits for the stylesheet.
This is sensible behaviour rather than a flaw. Without it every page would flash unstyled before settling, which readers find worse than a short wait.
Scripts are parser blocking unless specifically marked as asynchronous or deferred. A script can rewrite the page, so the browser stops reading until it knows what the script did.
So render-blocking CSS delays the paint, and render-blocking JavaScript delays the parse. Both end in the same place, with a visitor looking at nothing.
Knowing which one you are dealing with matters, because the remedy differs. You cannot fix render-blocking CSS with an attribute, and you usually can fix a script with one.

How to Eliminate Render-Blocking Resources
Five fixes, in order from safest to most involved. Work down the list and stop when the page is fast enough rather than when the score is perfect.
1. Add defer to your scripts
Most scripts in the head do not need to run before the page is drawn. Adding defer lets the parser continue and runs the script once parsing is finished.
Start with the obvious ones. Chat widgets, analytics, review badges and anything else that appears after the page is already useful.
Those are also the lowest risk, because nothing else on the page is waiting for them. Deferring a chat widget cannot break a menu.
In the defer vs async question, defer is the safer answer for anything that depends on another script, because it preserves the order they were written in.
Use async only for things that stand alone, such as an analytics tag. Anything that touches the page or another library should be deferred instead.
If you are unsure which a script is, defer it. The defer vs async decision has a safe default and this is it.

2. Fix render-blocking CSS by splitting on media
A stylesheet only blocks when its media attribute matches the device. Split print styles into their own file with media set to print and they stop blocking entirely.
The same applies to styles only needed at larger widths. It is the lowest risk way to fix render-blocking CSS, and nothing visible changes.

3. Inline the critical CSS
The documented approach is to inline the CSS needed for the first paint in a style block in the head, then load the remainder asynchronously using preload.
This is effective and it is the fix most likely to break something visually, so it belongs after the first two rather than before them.
Test it on a copy first. A mistake here produces a page that renders unstyled for a moment, and that looks worse to a visitor than a slightly slower load.
Most plugins that offer this feature do it imperfectly. Check the home page, a service page and an article, because each uses different styles.

4. Remove what nothing uses
Unused CSS and JavaScript still has to be downloaded and parsed. Removing unused code is named directly in Chrome's recommendations.
A page carrying styles for a slider it does not use, from a theme demo nobody removed, is the ordinary case rather than the exception.
On a site built from a theme and several plugins this is usually the largest single saving available, and nobody wants to do it.
Start by listing the plugins loading assets on every page. Most sites carry at least one that is only needed on a single page and loads everywhere.
A contact form plugin loading its stylesheet on every article is the classic example, and limiting it to the contact page is a settings change rather than development.

5. Watch the fonts
Fonts are not flagged as render blocking in the same way, and they produce the same symptom. The page is visible but the words are not there yet.
Control it with font-display and keep the number of families small.
Two families is enough for most sites. Each extra one is another file competing with the files you already decided were critical.
Weights count too. Four weights of one family is four files, and most pages use two of them.
Check what the page actually renders in before deleting any. A weight used only by one heading is still a weight somebody will notice disappearing.

Tools for Finding Render-Blocking Resources
| Tool | What it gives you | Limit |
|---|---|---|
| Lighthouse | A list of URLs blocking first paint | A lab test, not real visitors |
| PageSpeed Insights | The same audit plus field data | Field data needs enough traffic |
| Browser network panel | The real order things loaded in | Reflects your connection only |
| Search Console | Core Web Vitals across your pages | Grouped, so slow to react |
Treat the score as a pointer and the list of URLs as the actual output. Nobody visiting your site sees the score.
Run the test twice before acting on it. A single lab run varies enough to send you chasing a file that was simply slow that minute.

Common Mistakes When Fixing Render-Blocking JavaScript
- Deferring everything at once. Scripts that depend on each other break, and the page looks fine until a form stops submitting.
- Using async where defer was needed. Async runs on arrival, so dependent scripts can run in the wrong order.
- Inlining critical CSS first. It is the highest risk fix and it should follow the cheap ones.
- Chasing the score. The LCP target of 2.5 seconds at the 75th percentile is the real measure.
- Testing only on your own machine. A fast connection hides exactly what you are fixing.
- Adding a plugin on top of a plugin. Two optimisers fighting over the same files is a common cause of a broken layout.
- Fixing everything in one change. When something breaks you will not know which of the six edits did it.

FAQs
What is a render-blocking resource?
A file the browser has to handle before it can paint anything. Lighthouse flags two kinds: a script tag in the head with no defer or async attribute, and a stylesheet link with no disabled attribute whose media attribute matches the device, which includes media set to all.
Why is CSS render-blocking by default?
Because the browser cannot safely draw content it might have to restyle a moment later. Web.dev puts it as some resources being deemed so critical that the browser pauses page rendering until it has dealt with them. Scripts are parser blocking unless marked async or deferred.
What is the difference between defer and async?
Both stop a script blocking the parser while it downloads. Async runs the script as soon as it arrives, which can still interrupt parsing. Defer waits until parsing is finished and preserves the order scripts were written in, which makes it the safer default.
What is critical CSS?
The small amount of styling needed to draw the first screen. The documented approach is to inline that CSS in a style block in the head and load the remainder asynchronously, so the browser can paint without waiting for a full stylesheet it mostly does not need yet.
How fast should the page actually be?
Google's target is a Largest Contentful Paint of 2.5 seconds or less, measured at the 75th percentile of page loads and segmented across mobile and desktop. That is the number worth fixing towards, rather than chasing a score in a testing tool.
Conclusion
Deal with render-blocking resources in order. Defer the scripts, split the stylesheets by media, then consider inlining the critical CSS.
Change one thing at a time and load the site afterwards. Speed work breaks pages quietly, and the break is usually only visible on one template.
Measure against Largest Contentful Paint rather than a score, and test on a connection like your customers' rather than yours.
Then stop. Most small sites reach a good LCP after the first two fixes, and the remaining render-blocking resources cost more to remove than they are worth.
If you would rather have this done as part of a build, see how we approach web design.









