Render-blocking resources: CSS en JavaScript die je pagina ophouden
In dit artikel
Render blocking betekent dat de browser niets op het scherm zet totdat bepaalde bestanden zijn opgehaald en verwerkt. Het gaat bijna altijd om stylesheets (CSS) en scripts (JavaScript) die bovenaan in de code van je pagina staan. Je bezoeker kijkt zolang naar een leeg scherm. De oplossing zit in de bouw: scripts met defer of async laden, alleen de CSS meesturen die het eerste scherm nodig heeft en zuinig zijn met lettertypes en externe scripts. Zo bouw ik mijn maatwerksites, en zo bewaak ik ze bij elke wijziging.
Wat betekent render blocking?
Render blocking betekent dat een bestand de browser verhindert om de pagina op het scherm te zetten. Renderen is het tekenen van de pagina: tekst, kleuren en afbeeldingen op de juiste plek. Zolang een blokkerend bestand niet binnen is, blijft het scherm leeg, ook als de tekst van de pagina allang is aangekomen.
Dat komt door de manier waarop een browser werkt. Hij leest de HTML van boven naar beneden. Komt hij bovenaan een stylesheet tegen, dan wacht hij met tekenen tot die binnen is. Anders zou hij eerst een kale pagina tonen die daarna opeens verandert. Komt hij een gewoon script tegen, dan stopt hij zelfs met lezen: het script kan de pagina immers nog aanpassen, dus hij wacht tot het is opgehaald en heeft gedraaid.
Vergelijk het met een toneelvoorstelling. Het doek gaat pas open als het decor staat. Dat is logisch, maar als de decorbouwers nog drie vrachtwagens moeten uitladen die voor de eerste scène niet eens nodig zijn, zit het publiek onnodig te wachten.
Het effect zie je in de metingen. De First Contentful Paint, het moment waarop de eerste tekst of afbeelding verschijnt, schuift op. En daarmee ook de Largest Contentful Paint, een van de drie Core Web Vitals.
Welke bestanden blokkeren en welke niet
Niet alles wat bovenaan staat, houdt de pagina op. Dit zijn de regels die Lighthouse hanteert, aangevuld met hoe browsers volgens MDN met scripts omgaan:
| Wat er in de code staat | Blokkeert? | Waarom |
|---|---|---|
<link rel="stylesheet"> bovenaan |
Ja | De browser wil de opmaak hebben voordat hij tekent |
Stylesheet met media="print" |
Nee | Die opmaak geldt alleen bij afdrukken, dus de browser wacht er niet op |
<script src="..."> in de head |
Ja | De browser stopt met lezen tot het script is opgehaald en heeft gedraaid |
Script met defer of async |
Nee | Het script laadt mee terwijl de browser verder leest |
Script met type="module" |
Nee | Moderne modules gedragen zich standaard als defer |
| Afbeeldingen en video | Nee | Die tekent de browser zodra ze binnen zijn |
| Lettertypebestanden | Nee, maar | Ze kunnen de tekst tijdelijk onzichtbaar houden |
Het probleem zit dus vrijwel altijd in twee dingen: stylesheets en scripts zonder defer of async bovenaan de pagina. En het wordt erger naarmate ze groter zijn, of van een ander domein komen, omdat de browser dan eerst een nieuwe verbinding moet opzetten.
Waar je het ziet in PageSpeed Insights
In PageSpeed Insights staat het op het tabblad voor mobiel onder de scores, bij het onderdeel Insights. Daar vind je een melding over render blocking requests, met een lijst van de bestanden die het tonen van de pagina ophouden en hoeveel tijd dat kost. In oudere versies heette die melding Eliminate render-blocking resources. Je ziet hem soms in het Nederlands vertaald.
Die lijst is een startpunt, geen rapportcijfer. Per bestand zijn er drie vragen:
- Van wie is het? Een bestand van je eigen domein, of van een externe dienst zoals een lettertype, chat of statistiekentool?
- Is het nodig voor het eerste scherm? Een stylesheet voor de kop en het menu wel, een script voor een fotogalerij onderaan niet.
- Hoe groot is het? Een groot stylesheet bevat vaak opmaak voor de hele site, waarvan deze pagina maar een klein deel gebruikt.
Hoeveel van een bestand echt wordt gebruikt, laat het tabblad Coverage in de ontwikkelaarstools van Chrome zien: per CSS- en JavaScript-bestand welk deel tijdens het laden is gebruikt en welk deel niet.
Staat de melding er niet, of kost het maar een fractie van een seconde? Dan is dit niet je grootste probleem. Wat de score in die test wel en niet betekent, lees je in Lighthouse-score van 100: moet dat eigenlijk?.
Scripts: defer en async, en waarom dat geen schakelaar is
Bijna geen script hoeft het tonen van de pagina op te houden. Technisch scheelt het één woord in de code. Zo ziet dat eruit:
<!-- Blokkeert: de browser stopt tot dit script binnen is en heeft gedraaid -->
<script src="/js/menu.js"></script>
<!-- Blokkeert niet: laadt mee, draait als de pagina gelezen is, in volgorde -->
<script src="/js/menu.js" defer></script>
<!-- Blokkeert niet: draait zodra het binnen is, volgorde niet gegarandeerd -->
<script src="https://statistieken.voorbeeld.nl/script.js" async></script>
De vuistregel: defer voor scripts die met je pagina samenwerken, zoals een menu, een filter of een formuliercontrole. async voor losse scripts die niet van andere afhankelijk zijn, zoals een statistiekentool. defer en async werken alleen bij scripts met een eigen bestand. Een script dat direct in de HTML staat, moet klein blijven of onderaan de pagina staan.
Dat ene woord is ook waar het misgaat bij bestaande sites. Hangt script B van script A af, en laadt A ineens met async, dan kan B draaien voordat A klaar is. Het menu klapt niet meer open, het formulier verstuurt niet of de cookiemelding verschijnt te laat. Soms alleen op tragere telefoons, zodat niemand het meteen merkt.
De beste oplossing is minder JavaScript. Voor een menu of een uitklapblok is geen framework nodig: een paar regels gewone code volstaan, en zo bouw ik dat ook. Wanneer een framework zijn gewicht wel waard is, bespreek ik in een JavaScript-framework kiezen. En een pagina die eerst als gewone HTML werkt en JavaScript als extra laag krijgt, hoeft nergens op te wachten. Dat heet progressive enhancement.
CSS: minder, en alleen wat het eerste scherm nodig heeft
CSS moet blokkeren, maar het kan veel kleiner. Er zijn drie lagen, van eenvoudig naar bewerkelijk.
Minder CSS. Veel thema's en frameworks sturen opmaak mee voor onderdelen die je nergens gebruikt: sliders, tabbladen, tientallen knopvarianten. Ongebruikte opmaak weghalen scheelt direct, maar vraagt zorg. Wat op de ene pagina ongebruikt lijkt, kan op een andere pagina of in een uitklapmenu nodig zijn. Samenpersen, waarbij spaties en commentaar worden verwijderd, helpt daarnaast een beetje.
Opmaak die niet nodig is apart laden. Opmaak voor afdrukken staat in een eigen bestand met media="print". Die blokkeert dan niet.
Kritieke CSS in de pagina zelf. De opmaak die het eerste scherm nodig heeft, staat direct in de HTML. De rest van de opmaak laadt pas daarna. Samen met de vorige laag ziet de head van een pagina er dan ongeveer zo uit:
<!-- Kritieke CSS: direct in de pagina, geen apart bestand -->
<style>
/* Alleen wat het eerste scherm nodig heeft: kop, menu, blok bovenaan */
</style>
<!-- Opmaak voor afdrukken: blokkeert niet -->
<link rel="stylesheet" href="/css/print.css" media="print">
Google zegt zelf dat dat laatste een geavanceerde techniek is en dat de meeste sites hun doelen ook zonder halen. Het is bewerkelijk om bij te houden: elke wijziging aan de opmaak kan betekenen dat de kritieke CSS opnieuw moet worden bepaald. Bij een site die bij elke wijziging opnieuw wordt gebouwd, zoals een site met een static site generator, kan dat automatisch tijdens het bouwen. Bij een site die met de hand wordt bijgehouden, is minder CSS meestal de betere investering.
Een maatwerksite heeft hier een voorsprong op een thema. Een thema moet passen bij duizenden sites en neemt de opmaak voor al die sites mee. Bij een maatwerksite die ik bouw, is de opmaak geschreven voor die ene site, dus er gaat geen opmaak mee voor een slider die nergens staat.
Lettertypes: de omweg via een ander domein
Lettertypes zijn een bekende verborgen blokkade. Niet het lettertypebestand zelf houdt de pagina op, maar het stylesheet dat het lettertype aankondigt. Bij Google Fonts via de servers van Google is dat een stylesheet van een ander domein: de browser moet eerst een extra verbinding opzetten en wacht tot dat bestand binnen is. Daarna volgen de lettertypebestanden zelf, weer van een ander domein.
Wat die omweg korter maakt:
- Het stylesheet hoort via een
<link>in de head te laden, niet via@importin de eigen CSS. Met@importontdekt de browser het lettertype pas als hij het eigen stylesheet heeft opgehaald en gelezen. Dan wacht hij twee keer na elkaar. - Een vooraf opgezette verbinding met het domein van de lettertypes, via een regel in de head, wint tijd voordat het stylesheet aan de beurt is.
Het lettertype op het eigen domein hosten haalt het externe domein helemaal weg. Waarom de tekst met font-display meteen leesbaar blijft en welke privacykant er aan Google Fonts zit, staat in lettertypes op je website.
Externe scripts: elke dienst wil bovenaan
Een groot deel van de blokkades komt niet van je eigen site, maar van diensten die zijn toegevoegd: een chatwidget, een cookiemelding, een tool voor A/B-tests, een kaart of een social-mediafeed. Vaak staat hun code bovenaan, omdat de handleiding van de leverancier dat zo voorschrijft.
Een paar voorbeelden van wat je tegenkomt:
- Tools voor A/B-tests verbergen de pagina soms bewust totdat hun script binnen is, zodat bezoekers niet zien dat er iets verandert. Dat is in feite een ingebouwde blokkade.
- Chat en social-mediafeeds laden vaak hun eigen stylesheets en lettertypes bovenop die van jou.
- Kaarten en video's halen bij het laden van de pagina al code op, ook als niemand ze gebruikt.
Per dienst is de vraag of hij bovenaan moet staan, of hij op elke pagina nodig is en of hij nog iets oplevert. En of hij eigenlijk pas mag laden na toestemming via de cookiemelding. Op een pagina met een formulier voor gevoelige gegevens hoort vaak helemaal geen dienst van buiten thuis. Elke dienst die niet meelaadt, kan de opbouw van je pagina ook niet ophouden. Hoe je zo'n afweging maakt en wat de alternatieven zijn, lees je in externe scripts op je website.
Waarom één schakelaar meestal niet werkt
Er zijn plugins en diensten die met één schakelaar alle CSS en JavaScript uitstellen of samenvoegen. Dat kan veel winst opleveren, maar ook je site breken: een menu dat niet meer openklapt, een formulier dat niet verstuurt, een cookiemelding die te laat verschijnt of niet meer werkt. Wie zulke opties gebruikt, moet ze één voor één aanzetten en na elke stap de belangrijkste pagina's testen, op mobiel en desktop. En opnieuw na elke update van een plugin of thema. Draai je op WordPress, dan staat die aanpak in WordPress website sneller maken.
Een maatwerksite van mij heeft zo'n plugin niet nodig: de volgorde van stylesheets en scripts zit in de bouw zelf. Verander ik later iets aan die volgorde, dan controleer ik zelf of menu, formulieren en cookiemelding nog werken voordat het live gaat. Gaat het om meer dan een detail, zoals een nieuwe functie, dan bekijk je die eerst op een aparte testversie van je site, en live gaat hij pas als jij akkoord geeft. Wat zo'n testversie is, staat in staging-omgeving.
Jaag ook niet op een lege lijst. Een klein stylesheet van je eigen domein dat het eerste scherm opmaakt, mag blijven staan. Dat is precies waar render blocking voor bedoeld is.
Conclusie: laat alleen het eerste scherm wachten op wat het nodig heeft
Render blocking betekent dat stylesheets en scripts bovenaan je pagina de browser laten wachten met tekenen. Je ziet ze in PageSpeed Insights onder Insights. De grootste winst zit meestal in scripts met defer of async, minder CSS, lettertypes die niet via een omweg laden en externe scripts die niet bovenaan hoeven. Kritieke CSS in de pagina zelf is de laatste stap, en voor de meeste sites niet nodig.
Voor jou betekent dat: het is geen kwestie van één instelling, maar van hoe je site in elkaar zit. Elk woord in de code kan een menu, formulier of cookiemelding raken. In mijn maatwerksites zit de snelle opbouw in de techniek zelf, en niets gaat live zonder dat ik het heb nagelopen. Wil je weten of de vertraging misschien al eerder begint, bij je server? Lees dan TTFB: waarom je server de eerste vertraging is. Benieuwd hoe ik websites bouw en beheer? Download het pitchdeck.
Veelgestelde vragen
Wat is het verschil tussen defer en async?
Bij allebei haalt de browser het script op terwijl hij doorgaat met het lezen van de pagina, dus geen van beide houdt het tonen van de pagina op. Het verschil zit in wanneer het script draait. Met defer wacht het script tot de hele pagina is gelezen, en draaien meerdere scripts in de volgorde waarin ze in de code staan. Met async draait het script zodra het binnen is, en is de volgorde niet gegarandeerd. Defer is de veilige standaard, async past bij losse scripts zoals statistieken.
Wat is kritieke CSS?
Kritieke CSS, in het Engels critical CSS, is het kleine deel van je opmaak dat nodig is om het eerste scherm te tonen: de kop, het menu en het blok bovenaan. Die regels staan direct in de HTML van de pagina, zodat de browser niet hoeft te wachten op een apart bestand. De rest van de opmaak laadt daarna. Het levert winst op, maar het is bewerkelijk om bij te houden. Google noemt het zelf een geavanceerde techniek die de meeste sites niet nodig hebben.
Is render blocking altijd slecht?
Nee. Dat CSS het tonen van de pagina ophoudt, is met opzet. Zonder die pauze zou je bezoeker eerst een kale pagina zonder opmaak zien die daarna opeens verandert. Het doel is dus niet om alle blokkades weg te halen, maar om ze zo klein en kort mogelijk te maken. Een stylesheet van een paar kilobyte vanaf je eigen domein is prima. Vier stylesheets van verschillende diensten en een handvol scripts bovenaan in de code zijn dat niet.
Blokkeren lettertypes het renderen?
Het lettertypebestand zelf houdt de pagina niet op. Wat wel blokkeert, is het stylesheet dat de lettertypes aankondigt, zeker als dat van een ander domein komt, zoals bij Google Fonts via de servers van Google. De browser moet dan eerst een extra verbinding opzetten en dat bestand ophalen voordat de pagina kan verschijnen. Het lettertypebestand kan daarna wel de tekst even onzichtbaar houden, maar dat is op te vangen met een instelling in de CSS, font-display. Het lettertype op je eigen domein hosten haalt de omweg helemaal weg.
Kan een snelheidsplugin render blocking oplossen?
Soms deels. Zulke plugins stellen met één schakelaar alle scripts uit of voegen stylesheets samen. Dat kan de melding in PageSpeed Insights laten verdwijnen, maar ook een menu, formulier of cookiemelding laten haperen, vooral als scripts van elkaar afhankelijk zijn. Elke optie moet daarom apart worden aangezet en getest, en na een update van een plugin of thema opnieuw. De plugin werkt bovendien achteraf om de code heen. In mijn maatwerksites regel ik de volgorde van stylesheets en scripts in de bouw zelf, zonder plugin.
Benieuwd hoe ik dit in de praktijk aanpak?
Het pitchdeck laat de hele werkwijze zien.
Geschreven door Dennis Boekhout
Marketing freelancer uit 's-Hertogenbosch. Volg op LinkedIn (opent in een nieuw tabblad)
