Optimaliseer de LCP Resource Load Delay

Van vertraging naar weergave: leer hoe je de Resource Load Delay van de Largest Contentful Paint verbetert

Arjen Karel
Bijgewerkt · 21 min lezen
Delen

Deze gids is onderdeel van de Largest Contentful Paint (LCP) hub. Resource Load Delay is vaak de grootste veroorzaker van een slechte LCP-score, vooral bij SPA-sites! 

Optimaliseer de LCP Resource Load Delay

Largest Contentful Paint (LCP) bestaat uit vier subfasen: TTFB, Resource Load Delay, Resource Load Duration en Element Render Delay. 

Korte tip: is je LCP een afbeelding, dan scoort die bijna altijd slechter dan tekst. Houd je LCP-elementtypes bij in je RUM-data, anders vaar je blind.

Wat is Resource Load Delay?

Resource Load Delay is de tijd tussen de TTFB en het moment dat de browser de download van de LCP-resource start. In principe moet een browser een LCP-resource (zoals de LCP-afbeelding)  zo snel mogelijk in de wachtrij zetten. Gebeurt dat niet zo snel mogelijk, dan komt dat meestal doordat de browser hem niet direct kan vinden of hem niet belangrijk genoeg vindt.

Een hoge waarde duidt op een architectuurprobleem (waarbij de browser de resource-URL niet kan vinden in de initiële HTML-payload. Zie de resource load delay als de tijd die de browser kwijt is om te ontdekken dat de LCP-resource nodig is en te besluiten hem op te halen.

Besef ook dat de resource load delay optreedt vóórdat de resource echt wordt geladen. Daarom heeft dit niets te maken met responsive images of nieuwe afbeeldingsformaten zoals WebP of AVIF.

LCP resource load delay sequence showing Time to first byte, Stylesheet, Script, Resource load delay leading to Image

Voor LCP-elementen die uit tekst bestaan en renderen met een systeemfont, is deze resource load delay meestal nul: er hoeft geen externe resource te worden opgehaald. Hogere waarden voor resource load delay zie je alleen bij LCP-elementen die afhankelijk zijn van een externe netwerkresource, zoals een afbeelding of een videobestand.

Hoe vindt een browser het LCP-element?

Om Resource Load Delay te verlagen, moet je begrijpen hoe browsers resources ontdekken (of in elk geval hoe ze het LCP-element ontdekken). Browsers gebruiken twee mechanismen: een snel pad en een traag pad. Zorg er eerst voor dat het LCP-element op het snelle pad zit.

Chrome DevTools screenshot showing Preload Scanner (Fast Path) and DOM Parser (Slow Path) resource discovery for LCP elements

  • De DOM-parser (het trage pad): Dit is de hoofdparser van de browser en het is een zwaargewicht. Hij bouwt de complete pagina op door de HTML en stylesheets in te lezen en met JavaScript te werken. Dit is het trage pad: hij kan worden opgehouden of stilgelegd doordat andere bestanden eerst moeten downloaden en uitvoeren. Die keten van afhankelijkheden leidt direct tot vertraging.
  • De Preload Scanner (het snelle pad): Omdat de DOM-parser (relatief) traag is, hebben browsers een razendsnelle secundaire scanner. Die scant de pagina vliegensvlug op downloadbare resources en laat zich door niets tegenhouden.  Vindt hij <script>-, niet-lazy <img>- of <link>-tags, dan zet hij die meteen in de wachtrij voor download, nog vóór CSS is geparsed of JavaScript is uitgevoerd. Dit is de optimale route voor elke kritieke resource.

De complete strategie om Resource Load Delay te optimaliseren rust op één principe: zorg dat de preload scanner de URL van de LCP-resource zo vroeg mogelijk kan ontdekken.

Voor een LCP-element betekent dat twee dingen:

  1. Zorg dat de preload scanner hem kan vinden via een normale image-tag die geen loading="lazy"-attribuut heeft.
  2. Zorg dat de preload scanner niet te veel minder belangrijke resources voorrang geeft.
Hieronder leg ik dit allemaal in detail uit! Maar onthoud voor nu dit: elk patroon dat de URL verbergt voor het initiële HTML-document, dwingt de browser naar het trage ontdekkingspad. Die wachttijd vertaalt zich direct naar Resource Load Delay. Elke effectieve optimalisatie draait om het aanpassen van je HTML om de LCP-resource zo hoog mogelijk op het snelle pad te krijgen. Zie voor een complete gids over browser-resourceprioritering ons artikel over resource prioritization.

Lighthouse test dit via de melding LCP request discovery: de regel "Request is discoverable in initial document" faalt als een CSS-bestand of script het request voor de LCP-afbeelding start in plaats van de HTML of een preload.

Waarom Load Delay belangrijk is voor de Core Web Vitals

Beginnende developers denken vaak dat LCP een "bestandsgrootte"-probleem is. Teams focussen daardoor op beeldcompressie, moderne afbeeldingsformaten en responsive images. Dat is een vergissing. Uit ons eigen Core Web Vitals-onderzoek blijkt dat het grootste knelpunt bij LCP de TTFB is (48%), gevolgd door Load delay (24%). Load time beslaat slechts 10%, gevolgd door Render delay met 17%.

LCP component breakdown chart showing TTFB at 48.61% as largest bottleneck followed by Load delay at 23.89% from Core Web Vitals research

Het mooie is: load delay kun je vrijwel helemaal oplossen, terwijl TTFB altijd blijft bestaan. Daardoor heeft Load delay het grootste optimalisatiepotentieel.

Zo meet je Resource Load Delay

Wil je Resource Load Delay oplossen, meet het dan eerst nauwkeurig. De workflow is altijd: check eerst CrUX om het probleem met data van echte gebruikers (RUM) vast te stellen, en duik daarna pas Chrome DevTools in voor een diepe analyse.

Stap 1: Check met CrUX.

CrUX bevat openbare field data van Google over echte Chrome-gebruikers, weergegeven als een voortschrijdend venster van 28 dagen voor je Core Web Vitals op het 75e percentiel. Het toont of een cijfer goed of slecht is, maar vertelt niet wie, wat of waarom. Omdat Google leunt op CrUX-data, is dit je beste vertrekpunt.

Ga naar cruxvis.withgoogle.com, vul je website in, ga naar Loading Performance en klik op  Largest Contentful Paint (LCP) image subparts

CrUX visualization of Resource Load Delay at p75 showing ≤2718 ms for desktop page loads

Stap 2: Analyseer field data (RUM)

RUM verzamelt Core Web Vitals van al je echte gebruikers en geeft een veel specifieker, gedetailleerder beeld. Het laat zien wie en wat, gesegmenteerd zoals jij wilt (en die informatie is goud waard), maar niet waarom.

Dit screenshot van CoreDash laat bijvoorbeeld zien welke URL's last hebben van Resource Load Delay (in het groen)

CoreDash LCP breakdown by top-level pathname with green distribution bars indicating Resource Load Delay percentages

Stap 3: Diagnoseer met DevTools

Zodra je RUM-data de probleem-pagina en het LCP-element heeft aangewezen, gebruik je Chrome DevTools om de oorzaak te achterhalen. Het doel is om het probleem te reproduceren en de LCP-subfasen te meten voor een exacte Resource Load Delay-waarde. In DevTools doe je ook een analyse van de main thread om te zien welke taken draaien en het renderproces mogelijk blokkeren.

Chrome DevTools Performance panel highlighting LCP Load Delay with red arrow on jlwagner-v7.jpg resource

Stappenplan: we schreven een complete walkthrough voor deze workflow: Diagnose LCP with the Chrome DevTools Performance panel. Daarin behandelen we de throttling-instellingen, het opnemen van een trace en het aflezen van de exacte Resource Load Delay-waarde uit het LCP-breakdown-inzicht.

Veelvoorkomende oorzaken en effectieve fixes

Een hoge Resource Load Delay heeft één van twee oorzaken: de LCP-resource wordt te laat ontdekt, of krijgt een lage fetch-prioriteit. Dit zijn de meest voorkomende architectuurfouten en de bijbehorende fixes.

Oorzaak: LCP geladen via CSS

Het probleem: De preload scanner parsed geen CSS-bestanden. Definieer je een LCP-afbeelding met een CSS background-image, dan is de URL onzichtbaar voor deze snelle scanner. De browser ontdekt de afbeelding pas na het downloaden van de HTML, het vinden van de CSS-link, het downloaden van het CSS-bestand, het bouwen van het CSSOM en het toepassen van de stijl. Deze keten van afhankelijkheden leidt direct tot een hoge Resource Load Delay. Zie voor meer informatie over dit patroon onze gids over deferring background images.

De oplossing: Gebruik simpelweg geen background-image voor kritieke LCP-elementen. Gebruik in plaats daarvan een standaard <img>-tag. Zo staat de URL van de afbeelding direct in de HTML en vindt de preload scanner hem meteen. Met CSS bereik je exact hetzelfde visuele resultaat.

Implementatievoorbeeld:

Anti-pattern (doe dit niet):

    <!-- CSS -->
   .hero {
      background-image: url('hero-image.jpg');
      height: 500px;
      width: 100%;
    }

    <!-- HTML -->
    <div class="hero"></div>
    

Best practice (doe dit in plaats daarvan):

    <!-- HTML -->
    <div class="hero-container">
      <img
        src="hero-image.jpg"
        alt="A descriptive alt text for the hero image"
        fetchpriority="high"
        class="hero-background-img"
        width="1200"
        height="500"
      />
      <div class="hero-content">
        <h1>Page Title</h1>
      </div>
    </div>

    <!-- CSS -->
   .hero-container {
      position: relative;
      height: 500px;
      width: 100%;
    }

   .hero-background-img {
      position: absolute;
      inset: 0; /* Equivalent to top: 0; right: 0; bottom: 0; left: 0; */
      width: 100%;
      height: 100%;
      object-fit: cover; /* This property mimics background-size: cover */
      z-index: -1; /* Places the image behind other content */
    }
    

Deze opzet levert hetzelfde visuele resultaat op, maar zorgt dat de browser de LCP-afbeelding zo vroeg mogelijk ontdekt. Dat minimaliseert de load delay.

Oorzaak: client-side rendering en JavaScript-injectie

Het probleem: Applicaties die client-side rendering (CSR) frameworks zoals React of Vue gebruiken, serveren vaak een minimale HTML-shell. De echte content, inclusief de LCP-<img>-tag, wordt pas door JavaScript in de DOM geplaatst nadat grote framework-bundles zijn gedownload, geparsed en uitgevoerd. Dit proces verbergt de LCP-resource voor de preload scanner en zorgt voor enorme vertraging bij het ontdekken.

De oplossing: de meest effectieve fix is om de initiële render te verplaatsen van de client naar de server.

  • Server-Side Rendering (SSR) of Static Site Generation (SSG): Architectuurpatronen zoals SSR of SSG genereren de volledige HTML op de server. De browser ontvangt een compleet document met de <img>-tag en het src-attribuut, waardoor de preload scanner de LCP-resource direct ontdekt. Dit is de vereiste architectuur voor elke pagina waar prestaties cruciaal zijn.
  • Framework-specifieke optimalisaties: Moderne frameworks bieden ook ingebouwde optimalisaties. Zo heeft het Next.js <Image>-component een priority-property. Zet je deze op true, dan voegt het framework automatisch de juiste <link rel="preload">- en fetchpriority="high"-attributen toe. Zo wordt de afbeelding gegarandeerd ontdekt en met de juiste prioriteit opgehaald.

Oorzaak: loading="lazy" op de LCP-afbeelding

Het probleem: Dit is een veelgemaakte fout met grote gevolgen. Het attribuut loading="lazy" vertelt de browser letterlijk dat hij het ophalen van een afbeelding moet uitstellen tot deze dicht bij de viewport komt. Voor afbeeldingen below-the-fold is dit perfect, maar op een LCP-element above-the-fold werkt het averechts. De preload scanner van de browser negeert afbeeldingen met loading="lazy" bewust. Gevolg: een te late ontdekking en een torenhoge Resource Load Delay.

De oplossing: Dit vraagt om oplettendheid.

  • Verwijder loading="lazy" van de LCP-afbeelding: Elke afbeelding die waarschijnlijk het LCP-element is, mag absoluut geen loading="lazy"-attribuut hebben. Het standaardgedrag van de browser is loading="eager"; dat is precies wat je wilt voor kritieke content above-the-fold. Het loading-attribuut helemaal weglaten heeft hetzelfde effect.
  • Controleer en configureer third-party tools: Loop ook third-party tools na. Veel CMS-platforms zoals WordPress en diverse image-optimalisatie-plugins passen automatisch lazy loading toe op alle afbeeldingen. Configureer deze tools zo dat ze de LCP-afbeelding overslaan. Vaak doe je dit door een uitzondering in te stellen voor de eerste één of twee afbeeldingen op de pagina.

Oorzaak: suboptimale HTML-structuur en grote documenten

Het probleem: De preload scanner doorloopt het HTML-document van boven naar beneden. Staan niet-kritieke maar zware resources, zoals iconen in de header of chatwidget-scripts, hoger in de <body> dan het LCP-element? Dan worden die als eerste ontdekt en in de download-wachtrij gezet. Dit verbruikt direct initiële bandbreedte en kan het downloaden van de LCP-resource vertragen. Ook een groot HTML-document vormt een probleem: zit het LCP-element niet in het eerste datapakket dat de browser ontvangt (ongeveer 14 kB), dan loopt de ontdekking minstens één round-trip vertraging op.

De oplossing: Optimaliseer de structuur en prioriteit van content binnen de HTML.

  • Herschik de HTML: Plaats de <img>-tag of het tekstblok voor het LCP-element waar mogelijk zo hoog mogelijk in de <body>-tag.
  • Geef niet-kritieke afbeeldingen lagere prioriteit: Voor niet-essentiële afbeeldingen die vroeg in de HTML-code moeten staan (zoals iconen in een header), gebruik je loading="lazy". Dit zorgt dat de preload scanner ze overslaat, zodat de download-wachtrij vrij blijft voor het LCP-element.
  • Stel niet-essentiële scripts uit: Scripts voor analytics, advertenties of social-media-widgets zijn zelden nodig voor de initiële render. Verplaats hun <script>-tags naar het einde van de <body> of gebruik het defer-attribuut. Zo blokkeren ze de parser niet en concurreren ze niet om netwerkbandbreedte met de LCP-resource.

Geavanceerde prioritering met resource hints

Zodra de LCP-resource vindbaar is in de HTML, kun je resource hints inzetten om de browser expliciete instructies te geven over het ophalen. Met deze hints stuur je de ontdekking en prioritering nauwkeurig bij.

Vroege ontdekking afdwingen met <link rel="preload">

<link rel="preload"> is geen hint, maar een dwingend commando. Het dwingt de browser om een resource met hoge prioriteit te downloaden, zelfs als de hoofdparser deze nog niet kan vinden. Door dit in de <head> van je HTML te plaatsen, los je trage ontdekking direct op voor resources zoals fonts, CSS-achtergrondafbeeldingen of LCP-afbeeldingen die diep in de DOM zitten. Bekijk voor complete implementatiedetails en voorbeelden onze gids over how to preload the LCP image.

Werking

Plaats je een preload-link in de <head> van het HTML-document, dan herkent de preload scanner deze direct en zet hij de resource meteen in de download-wachtrij. Dit werkt ideaal voor resources zoals fonts die via @font-face in een externe stylesheet worden geladen, CSS-background-image LCP's (al heeft een <img>-tag de voorkeur) of een LCP-afbeelding die diep in een complexe DOM-structuur zit.

Responsive preloading

Bij het preloaden van responsive images is een cruciaal detail van belang. Om te zorgen dat de browser het juiste beeldformaat voor de viewport van de bezoeker preloadt en een onnodige dubbele download voorkomt, moet de <link rel="preload">-tag de attributen imagesrcset en imagesizes bevatten. Deze moeten exact overeenkomen met de attributen op de bijbehorende <img>-tag.

Voorbeeld van responsive preloading:

<link rel="preload" as="image"
      href="lcp-image-large.jpg"
      imagesrcset="lcp-image-small.jpg 400w, lcp-image-medium.jpg 800w, lcp-image-large.jpg 1200w"
      imagesizes="(max-width: 600px) 400px, (max-width: 1200px) 800px, 1200px"
      fetchpriority="high">

<img src="lcp-image-large.jpg"
     srcset="lcp-image-small.jpg 400w, lcp-image-medium.jpg 800w, lcp-image-large.jpg 1200w"
     sizes="(max-width: 600px) 400px, (max-width: 1200px) 800px, 1200px"
     alt="A descriptive alt text"
     fetchpriority="high"
     width="1200" height="675">
    

Mogelijke valkuil

Preloading lost de fetch timing op (Load Delay en Load Duration), maar niet de paint timing. Is de main thread geblokkeerd door zware JavaScript of render-blocking CSS op het moment dat de gepreloade afbeelding binnenkomt? Dan moet de afbeelding alsnog wachten op het renderen. Daarmee verschuif je het knelpunt simpelweg van Load Delay naar Element Render Delay.

fetchpriority="high" en de prioriteitenwachtrij van de browser

Het fetchpriority-attribuut is een hint die het relatieve belang van de download van een resource aangeeft. Hiermee beïnvloed je de prioriteit van een resource in de download-wachtrij van de browser.

Hoe browserprioriteit werkt

Ontdekt de browser resources tijdens het laden van de pagina, dan kent hij aan elke resource een intern prioriteitsniveau toe. Standaard beginnen afbeeldingen in de viewport met prioriteit "Low". Pas wanneer de browser de layout heeft berekend en vaststelt dat ze zichtbaar zijn, worden ze geüpgraded naar "High". Voor die upgrade moet de browser eerst CSS downloaden en parsen, wat voor vertraging zorgt. Met het attribuut fetchpriority="high" omzeil je dit proces volledig: de afbeelding krijgt direct bij ontdekking de prioriteit "High". Dit maakt een groot verschil voor LCP-afbeeldingen, omdat het de wachttijd voor de prioriteitsupgrade wegneemt.

preload vs. fetchpriority

Deze twee hints hebben verschillende, maar aanvullende doelen. preload beïnvloedt wanneer een resource wordt ontdekt en aan de wachtrij wordt toegevoegd. fetchpriority bepaalt het prioriteitsniveau zodra de resource in de wachtrij staat. Dit onderscheid is cruciaal: preload lost een late ontdekking op, terwijl fetchpriority een te lage prioriteit oplost. Voor veel LCP-afbeeldingen die al direct in de HTML staan, is alleen fetchpriority vaak al voldoende. Zie voor een complete uitleg over het samenspel ons artikel over resource prioritization.

Best practice voor LCP

Voor de LCP-afbeelding is de beste strategie om beide te combineren. Zorg eerst voor een vroege ontdekking: zet de <img>-tag vroeg in de HTML of gebruik preload. Voeg daarnaast fetchpriority="high" direct toe aan de <img>-tag (en aan de preload-link, als je die gebruikt). Deze combinatie zorgt ervoor dat de resource niet alleen vroeg wordt ontdekt, maar ook de hoogst mogelijke prioriteit krijgt in de strijd om bandbreedte met stylesheets of fonts.

Voorbeeld:

<img src="lcp-image.jpg" fetchpriority="high" alt="A critical hero image">

Wanneer gebruik je fetchpriority="low"

Het attribuut fetchpriority dient niet alleen om prioriteit te verhogen. Met fetchpriority="low" verlaag je juist de prioriteit van niet-kritieke resources die concurreren om bandbreedte met de LCP-afbeelding. Typische kandidaten zijn afbeeldingen above-the-fold die niet het LCP-element zijn (zoals kleine iconen of avatars in de header) en gepreloade resources die wel nodig zijn, maar geen haast hebben. Door de prioriteit van deze concurrerende resources expliciet te verlagen, geef je de LCP-afbeelding meer ademruimte op het netwerk.

<!-- LCP image: high priority -->
<img src="hero.jpg" fetchpriority="high" alt="Hero image" width="1200" height="600">

<!-- Non-critical above-fold image: low priority -->
<img src="avatar.jpg" fetchpriority="low" alt="Author avatar" width="48" height="48">

Bewezen resultaat

In een case study van Google Flights verbeterde het toevoegen van fetchpriority="high" aan de LCP-achtergrondafbeelding de LCP-tijd van 2,6 naar 1,9 seconden: een winst van 700 ms.

Third-party verbindingen optimaliseren: preconnect en dns-prefetch

Het probleem

Staat je LCP-resource op een third-party domein, zoals een image-CDN of een font-provider zoals Google Fonts? Dan moet de browser een nieuwe netwerkverbinding met dat domein opzetten. Dit proces vereist een DNS-lookup, een TCP-handshake en een TLS-onderhandeling. Die moeten allemaal worden afgerond voordat de eerste byte van de resource kan worden gedownload. Deze opzettijd van de verbinding draagt bij cross-origin assets direct bij aan de Resource Load Delay.

De oplossingen

  • preconnect: Deze hint geeft de browser de opdracht om vooraf op de achtergrond de complete verbinding (DNS, TCP en TLS) met een specifieke third-party origin op te zetten. Wordt de resource echt opgevraagd, dan is de verbinding al warm en heb je geen wachttijd voor de opzet. Dit werkt uiterst effectief en is aan te raden voor de één of twee belangrijkste third-party domeinen die LCP-resources serveren.
  • dns-prefetch: Dit is een lichtere hint die alleen de DNS-lookup voor een domein uitvoert. Het levert minder tijdswinst op dan preconnect, maar heeft bredere browserondersteuning. Handig als fallback of voor minder kritieke third-party domeinen.

Best practice voor implementatie

Voor maximale compatibiliteit geef je beide hints mee. Ondersteunt de browser preconnect, dan gebruikt hij die; zo niet, dan valt hij terug op dns-prefetch. Het crossorigin-attribuut is verplicht voor resources die via CORS worden opgehaald, zoals fonts.

<link rel="preconnect" href="https://my-image-cdn.com" crossorigin>
<link rel="dns-prefetch" href="https://my-image-cdn.com">

<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>    

Tabel: Resource hints vergelijken voor LCP-optimalisatie

Om verkeerd gebruik te voorkomen en het specifieke doel van elke hint te verduidelijken, zet de onderstaande tabel ze op een rij.

Hint Type Hoofddoel Impact op LCP Load Delay Beste use-case voor LCP
preload Directive Vervroegd ophalen van een specifieke resource afdwingen Neemt ontdekkingsvertraging voor laat gevonden resources direct weg Een laat ontdekte LCP-afbeelding (bijv. via CSS-background-image) of font.
fetchpriority Hint Downloadprioriteit van een ontdekte resource aangeven Verkort wachttijd in de wachtrij door voorrang te geven boven andere assets De LCP-<img>-tag zelf, om te zorgen dat deze downloadt vóór minder kritieke resources.
preconnect Hint Complete netwerkverbinding met een domein alvast opzetten Neemt de opzettijd voor cross-origin verbindingen weg (DNS, TCP, TLS) Het kritieke third-party domein waarop de LCP-afbeelding of het font staat.
dns-prefetch Hint Alleen de DNS-lookup voor een domein vooraf uitvoeren Verkort het DNS-gedeelte van de verbindingstijd naar een cross-origin domein Fallback voor preconnect of voor minder kritieke third-party domeinen.

Holistische en toekomstgerichte strategieën

Naast resource hints kunnen bredere architectuurbeslissingen de Resource Load Delay nog verder terugdringen.

De rol van een modern CDN

Een Content Delivery Network (CDN) vormt het fundament van webperformance en verlaagt de Resource Load Delay indirect, maar aanzienlijk – vooral voor LCP-resources.

  • Minder overhead bij het verbinden: Door assets te verdelen over een wereldwijd servernetwerk brengt een CDN content geografisch dichter bij de gebruiker. Dit verlaagt automatisch de round-trip time (RTT) voor de DNS-lookup, TCP-handshake en TLS-onderhandeling – allemaal onderdelen van de opzettijd. Voor een LCP-afbeelding op een CDN verkort dit direct de load delay.
  • Image-CDN's: Gespecialiseerde Image-CDN's bieden een dubbel voordeel. Ze combineren de nabijheid van een standaard CDN met geautomatiseerde optimalisaties die de Resource Load Duration verlagen, zoals on-the-fly schalen, comprimeren en converteren naar moderne formaten als AVIF en WebP.
  • Geavanceerde protocollen: Veel moderne CDN's ondersteunen HTTP/3, dat QUIC gebruikt in plaats van TCP. HTTP/3 versnelt het opzetten van verbindingen en voorkomt head-of-line blocking, wat zorgt voor een snellere en efficiëntere aflevering van resources over de hele linie.

Vertraging volledig elimineren met Speculation Rules

De Speculation Rules API kan LCP-vertraging bij vervolgnavigaties volledig wegnemen.

Werking

Via deze API geven developers declaratief aan de browser door naar welke URL's een bezoeker waarschijnlijk doorklikt. Op basis van die regels kan de browser een doelpagina alvast prerenderen in een verborgen achtergrondtab, nog vóór de bezoeker op de link klikt.

Impact op LCP

Klikt de bezoeker op een link naar een geprerenderde pagina, dan verloopt de navigatie vrijwel instantaan. De pagina is op de achtergrond immers al volledig geladen en gerenderd. Voor deze navigatie zakken TTFB, Resource Load Delay, Resource Load Duration en Element Render Delay vanuit het perspectief van de bezoeker effectief naar nagenoeg nul.

Praktijkvoorbeeld

Op een e-commerce-overzichtspagina kun je met speculation rules de productdetailpagina's voor de eerste paar artikelen in de lijst alvast prerenderen. Klikt een bezoeker op een van die producten, dan staat de pagina er direct.

Praktijkcases: van theorie naar praktijk

Deze optimalisaties leveren meetbare winst op in de praktijk.

  • Case 1: De enorme kracht van preloading: Een experiment van DebugBear op een pagina met hoge load delay toont een treffend voorbeeld. De LCP-afbeelding zat verstopt in een request-keten, waardoor de Resource Load Delay maar liefst 75% van de totale LCP-tijd opslokte. Door simpelweg één <link rel="preload">-hint toe te voegen om de afbeelding vroeg vindbaar te maken, daalde de Resource Load Delay naar slechts 2% van de LCP-tijd. Dit bewijst hoe een eenvoudige architectuur-fix een gigantisch performance-knelpunt kan oplossen.
  • Case 2: Het loading="lazy"-anti-pattern in de praktijk: Een developer op Stack Overflow meldde op desktop een bizarre LCP-load delay van 1.430 ms ondanks een snelle verbinding. De oorzaak bleek een image-optimalisatie-plugin die onterecht lazy loading toepaste op de LCP-afbeelding door het src-attribuut te vervangen door een transparante placeholder-SVG. De oplossing was simpel: schakel dit gedrag uit voor het LCP-element, zodat de browser de afbeelding direct ontdekt en eager inlaadt. Dit laat zien hoe third-party tools ongemerkt voor forse vertraging kunnen zorgen.
  • Case 3: De performancewinst van fetchpriority: De case study van Google Flights levert het harde bewijs voor expliciete prioritering. Door simpelweg fetchpriority="high" toe te voegen aan de LCP-achtergrondafbeelding van de pagina, verbeterde de LCP-score met 700 ms (van 2,6 naar 1,9 seconden). Dit bewijst dat een resource vroeg laten ontdekken niet altijd genoeg is: expliciet aangeven dat hij prioriteit heeft, is essentieel om de strijd om bandbreedte te winnen.

Netwerkinspectie in Chrome DevTools: Open DevTools met de sneltoets Ctrl + Shift + I, kies het tabblad "Network" en herlaad de pagina. Kijk naar de volgorde van inladen. Je LCP-resource moet een van de eerste items in de download-wachtrij zijn. Loopt deze achter op andere elementen, dan heb je een probleem met resource load delay. Hieronder zie je een voorbeeld van een site waar de resource load delay niet is geoptimaliseerd.

Chrome DevTools Network tab showing learn-compute-emoji.webp as an LCP resource with load delay issue

Gebruik Real User Monitoring (RUM)-data: RUM-tools loggen vaak LCP attribution data. Met RUM visualiseer je de uitsplitsing van LCP-subfasen (in de tijd of per pagina). Zo krijg je een haarscherp beeld van de load delay voor LCP-elementen op je hele site of per pagina. Het onderstaande voorbeeld toont een algemene LCP-breakdown met de bijbehorende load delay.

CoreDash timeline chart showing global LCP breakdown with Time To First Byte, Load Delay, Load Time, and Render Delay sections

Zo verbeter je Load Delay

Resource load delay ontstaat wanneer de volgorde en timing van downloads niet optimaal zijn. In de basis zijn er twee manieren om dit op te lossen: geef de LCP-resource voorrang of geef niet-LCP-resources minder prioriteit. Dit zijn de belangrijkste patronen:

LCP-tip: begrijp de preload scanner: Moderne browsers gebruiken een mechanisme dat de preload scanner heet. Deze scant de HTML razendsnel en zet resources direct in de download-wachtrij. Kan een resource niet door de preload scanner in de wachtrij worden gezet, dan moet hij wachten op de tragere DOM-parser – met vertraging tot gevolg. Zorgen dat je LCP-resources vindbaar zijn voor de preload scanner levert enorme winst op bij het verlagen van de load delay.

1. Optimaliseer de HTML-structuur

De browser (of de preload scanner) verwerkt je HTML van boven naar beneden en zet resources in de wachtrij op volgorde van binnenkomst. Hoe hoger de LCP-resource in de HTML staat, hoe eerder hij in de wachtrij belandt. Verwijder of stel overbodige resources bovenin de HTML uit om dit te optimaliseren:

  • Lazy-load onbelangrijke of verborgen afbeeldingen: Soms staan afbeeldingen (zoals vlaggetjes voor taalkeuzes of afbeeldingen in het menu) helemaal bovenin de HTML van je site. Die zijn lang niet zo belangrijk als het LCP-element. Door deze afbeeldingen te lazy-loaden slaat de preload scanner ze over, waardoor ze pas later in het laadproces aan de beurt komen.
  • Verplaats onbelangrijke scripts naar onderen: Verplaats scripts die voor het eerste renderen totaal overbodig zijn naar de onderkant van de pagina, zodat ze kritieke resources niet ophouden. Denk aan een chatwidget: niemand in de geschiedenis van het internet heeft ooit hoeven chatten vóórdat de pagina zichtbaar was!

2. Vermijd background-images

Achtergrondafbeeldingen zijn onzichtbaar voor de preload scanner; ze belanden dus altijd pas via de veel tragere DOM-parser in de wachtrij. Voorkom die vertraging door een gewone <img>-tag te gebruiken, gecombineerd met de CSS-property object-fit: cover om het uiterlijk van een background-image na te bootsen. Zo kan de preload scanner de afbeelding direct oppikken en in de wachtrij zetten.

3. Gebruik fetchpriority

Voeg het attribuut fetchpriority="high" toe aan je LCP-element om de browser direct te laten weten dat deze resource voorrang moet krijgen. Normaal gesproken laden afbeeldingen standaard met een lage of gemiddelde prioriteit. Pas tijdens de layout-fase schaalt de browser zichtbare elementen op naar hoge prioriteit. Met fetchpriority="high" start de download direct met hoge prioriteit, wat zorgt voor een snellere LCP.

Fetchpriority grijpt doorgaans minder hard in (en is minder dwingend) dan preloading: het bepaalt de relatieve prioriteit van een element (deze afbeelding is belangrijker dan andere afbeeldingen), maar maakt hem niet belangrijker dan bijvoorbeeld stylesheets of niet-blokkerende scripts.

<img src="hero-image.jpg" alt="Hero Image" fetchpriority="high">

4. Implementeer preloading

Preloading verandert de volgorde waarin de preload scanner bestanden in de wachtrij zet. Plaats de tag <link rel="preload"> in de head van de pagina om de browser kritieke resources – zoals de LCP-afbeelding – zo vroeg mogelijk te laten ophalen. Preloads gebruik je voor resources die pas later in de HTML voorkomen (en dus later in de wachtrij zouden komen) of zelfs voor resources die nog helemaal niet in de HTML staan (zoals bij sommige sliders). Voor maximaal effect plaats je preloads na stylesheets en vóór scripts in de head van de pagina.

<link rel="preload" as="image" href="hero-image.jpg">

5. Optimaliseer styles

Stylesheets worden normaal gesproken vóór de LCP-resource in de wachtrij gezet, en terecht: zonder stylesheets weet de browser niet hoe de pagina eruitziet en kan hij niet beginnen met renderen. Maar een te grote CSS-omvang en te veel losse stylesheets concurreren direct met de LCP-resource om de eerste bandbreedte.

6. Implementeer efficiënte lazy loading

Het loading-attribuut is een tweesnijdend zwaard. Gebruik loading="eager" (of laat het attribuut simpelweg weg, want "eager" is de browserstandaard) voor je LCP-resource, en pas loading="lazy" toe op afbeeldingen buiten beeld.

  • Laad het LCP-element eager in: Wordt het LCP-element met lazy loading ingeladen, dan zet de preload scanner het niet in de wachtrij. Het laadt daardoor veel te laat in, met slechte prestaties tot gevolg.
  • Lazy-load afbeeldingen in de viewport: Voor afbeeldingen die wel in de viewport staan maar géén LCP-resource zijn, gebruik je loading="lazy" om ze net iets later in de wachtrij te plaatsen. Dit vermindert de strijd om bandbreedte met de LCP-resource.
  • Voorkom lazy loading bij afbeeldingen buiten beeld: Afbeeldingen die niet in de zichtbare viewport staan, starten helemaal geen download. Dat voorkomt concurrentie om bandbreedte volledig.

7. Browsercaching

Door browsercaching sla je netwerk-requests over voor resources die al lokaal op het apparaat van de bezoeker zijn opgeslagen. Dit versnelt de eerste pageview niet, maar verbetert wel de laadtijd van vervolgpagina's en terugkerende bezoekers. Dit is hoe browsercaching helpt bij resource load delay:

  • Cache concurrerende resources: De LCP-resource zelf cachen is een uitstekende strategie, maar browsercaching verbetert de LCP resource load delay vooral door bestanden op te slaan die concurreren met de LCP-resource of deze kunnen vertragen, zoals scripts, stylesheets en afbeeldingen.
  • Verlaag de serverbelasting: Caching vermindert het aantal requests naar je server. Dat kan de prestaties van andere resources verbeteren doordat er bandbreedte en CPU-kracht op de server vrijkomt.

8. Gebruik Speculation Rules

Speculation Rules stelt browsers in staat pagina's te prefetchen of prerenderen op basis van voorspeld gedrag van de bezoeker. Prefetchen elimineert effectief de Time to First Byte-fase van de LCP en heeft geen invloed op de resource load delay. Prerenderen rendert de volgende pagina in een verborgen tab en downloadt alle resources van de pagina alvast. Dit neemt alle load delay voor het LCP-element volledig weg, zoals te zien is in deze voorbeeld-LCP-breakdown van een geprerenderde pagina.

Chrome DevTools LCP breakdown: Element render delay 52ms (100%) for prerendered page

9. Vermijd client-side rendering

Client-side rendering (CSR) is funest voor je resource load delay. Rendert een LCP-element client-side, dan wordt het pas via JavaScript in de pagina geïnjecteerd. De LCP-resource ontbreekt daardoor in de initiële HTML van de pagina. Gevolg: de browser moet eerst meerdere scripts downloaden en uitvoeren voordat hij de resource überhaupt in de wachtrij kan zetten.

Deze extra overhead vertraagt de laadtijd en schaadt de gebruikerservaring, omdat kritieke content langer op zich laat wachten. Voor optimale prestaties en snellere laadtijden vermijd je client-side rendering het best ten gunste van server-side rendering of static site generation. Daarmee staan LCP-resources direct klaar in de initiële HTML.

Volgende stappen: ga verder met het optimaliseren van LCP

Resource Load Delay is één van de vier LCP-fasen. Zodra je de ontdekkingsvertraging hebt geminimaliseerd, ga je verder met deze handleidingen:

  • Fix &amp;amp; Identify LCP Issues: De complete diagnose-methodiek om alle LCP-problemen op te sporen en te fixen.
  • Optimize the LCP Image: Keuze van afbeeldingsformaten, responsive images, preloading en veelgemaakte fouten bij afbeeldingen.
  • Resource Load Duration: Zodra de browser de resource ontdekt, verkort je de downloadtijd via compressie, moderne formaten en CDN-optimalisatie.
  • Element Render Delay: Is de resource eenmaal gedownload, zorg dan dat de browser deze direct kan painten door de main thread vrij te houden.
Arjen Karel

Een snellere site nodig?

Ik ben Arjen en ik maak al 17 jaar trage sites snel. Loop je tegen iets aan dat je zelf niet opgelost krijgt? Stuur me je URL, dan praten we even.

Stuur me je URL
Arjen Karel
Arjen Karel, Web performance consultant sinds 2009

Waarom werkt onze fix niet?

Soms serveert het CDN nog de oude HTML, of de fix zit in het desktop-template terwijl mobiel een ander template gebruikt. Stuur me je URL en het probleem, dan stuur ik je een paar momenten. Ik bekijk eerst je field data, daarna besteden we een uur aan je site, en binnen een dag heb je mijn notities op schrift. €350 excl. btw.

Stuur me je URL

Geen developer om de fix te bouwen? Ik doe het werk zelf, op een kopie van je site.