Presentation delay de l'INP : taille du DOM, layout et rendu

Le presentation delay s'étend du dernier gestionnaire d'événements à la frame à l'écran. Un DOM volumineux et du code qui s'exécute dans la frame l'allongent ; réduisez le rendu à chaque tap.

  • Bon ≤ 200 ms
  • À améliorer ≤ 500 ms
  • Mauvais > 500 ms
Arjen Karel
Mis à jour le · 11 min de lecture
Partager

Le presentation delay en bref

Le presentation delay est la troisième et dernière partie de l'Interaction to Next Paint (INP), après l'input delay et la processing duration : le temps écoulé entre la fin des gestionnaires d'événements et l'apparition de la frame suivante à l'écran. Il regroupe le calcul des styles par le navigateur, le layout et le paint, ainsi que les callbacks requestAnimationFrame et ResizeObserver. Un tap modifiant une grande partie de la page le rend donc long.

Où commence et se termine le presentation delay ?

Le presentation delay commence dès que le dernier gestionnaire d'événements de l'interaction s'est terminé et s'achève quand la frame affichant le résultat est à l'écran. Pour un tap, ces gestionnaires sont pointerdown, pointerup et click ; pour une touche, keydown et keyup. Chrome mesure l'interaction complète, de l'entrée jusqu'à cette frame, et arrondit le tout à 8 ms.

Chronologie d'un tap : input delay, puis processing duration, puis presentation delay jusqu'à la frame à l'écran ; dans le presentation delay s'exécutent les callbacks requestAnimationFrame, le style et le layout, les callbacks ResizeObserver, le paint, ainsi que le travail du compositeur et du GPU.

Un tap de l'entrée à la frame, avec le détail de ce qui s'exécute dans le presentation delay.

Dans le presentation delay s'exécutent, dans cet ordre, les callbacks requestAnimationFrame, le style et le layout de tout ce que les gestionnaires ont modifié, les callbacks ResizeObserver et le paint ; après le main thread interviennent le travail du compositeur et du GPU. Le layout que le gestionnaire force lui-même, en lisant une dimension après une modification, s'exécute dans le gestionnaire et compte dans la processing duration (forced reflow). Un tap qui ne change rien à l'écran a quand même un presentation delay : il se termine à la frame que le navigateur aurait pu peindre.

Chrome DevTools et Lighthouse l'appellent « Presentation delay » dans la décomposition de l'INP ; la bibliothèque web-vitals l'appelle presentationDelay et CoreDash « Presentation ». Les deux parties qui le précèdent ont leur propre page, input delay et processing duration ; le guide de l'INP réunit les trois.

Quelle part de l'INP représente le presentation delay ?

Sur l'ensemble des sites mesurés avec CoreDash, le presentation delay sur mobile atteignait 60 ms au 75e percentile sur les 28 jours précédant le 7 novembre 2026 : aussi long que la processing duration et environ le double de l'input delay (31 ms). Sur les taps lents sur mobile, avec un INP de 500 ms ou plus, sa médiane tournait autour de 140 ms, contre environ 210 ms d'input delay et 120 ms de processing.

Chaque partie a son propre percentile calculé sur ses propres interactions, les trois ne s'additionnent donc pas pour donner l'INP.

Un bon INP est de 200 ms ou moins au 75e percentile. Au-delà, commencez par la partie la plus longue de l'interaction la plus lente, comme le conseille la décomposition de l'INP de Chrome.

Qu'est-ce qui cause un presentation delay élevé ?

Un presentation delay élevé vient d'un tap qui force le navigateur à recalculer les styles et le layout d'une grande partie de la page, ou de callbacks requestAnimationFrame et ResizeObserver, qui s'exécutent dans la frame elle-même. La documentation de Chrome sur la décomposition de l'INP décrit un presentation delay élevé comme « un délai de rendu pour afficher le résultat de l'interaction après l'exécution du code du gestionnaire d'événements ».

  • Un changement de vue grille ou liste, un filtre ou un « charger plus » sur une longue collection. Chaque fiche produit voit son style et son layout recalculés : une trace montre Recalculate style sur des milliers d'éléments, puis Layout.
  • Un menu, un drawer ou une modale qui applique une classe sur <body> ou <html>. Chaque élément correspondant aux règles CSS de cette classe voit ses styles recalculés : regardez Elements affected sur Recalculate style.
  • Des filtres ou une recherche qui injectent du nouveau HTML pour toute la grille. Le navigateur analyse et effectue le rendu de l'ensemble : Parse HTML dans le gestionnaire, puis Recalculate style et Layout.
  • Une page React ou Vue qui re-rend la moitié de l'écran. Les mises à jour du DOM relèvent du processing ; le rendu du résultat constitue le presentation delay, soit le Recalculate style, le Layout et le Paint après le gestionnaire.
  • Du code dans requestAnimationFrame. Il s'exécute juste avant la frame et apparaît sous la forme Animation frame fired.
  • Des sliders et barres fixes qui se mesurent avec un ResizeObserver. Le callback s'exécute dans la frame après le Layout, ce qui se traduit par un Function call avant le Paint.
  • Une animation JavaScript ou un script de smooth scroll. Il tourne à chaque frame, y compris celle qui suit le tap : une trace affiche donc Animation frame fired sur chacune d'elles.
  • Des sélecteurs lents, comme :has() sur une grosse page. Chaque élément met plus de temps à recalculer ses styles, ce que montre l'onglet Selector stats de Recalculate style.

Un script qui s'exécute à chaque frame ralentit chaque tap sur la page ; aucun bouton en particulier ne ressort donc dans les field data. J'ai déjà vu un script de smooth scroll oublié ajouter 200 ms de presentation delay à chaque clic sur chaque page.

Un gros DOM : le bouton Liste sur 480 produits

La page de test est une catégorie de boutique en ligne avec 480 chaussures de randonnée, soit environ 12 000 éléments au total, où le bouton Liste applique une seule classe sur la liste de produits. Mesuré sous Chrome 158 en largeur mobile avec un CPU ralenti 4x, médianes sur cinq taps :

  • 480 produits : INP de 72 ms, dont 66 ms de presentation delay.
  • 480 produits avec content-visibility: auto sur les fiches : INP de 16 ms ou moins, presentation delay de 6 ms ou moins.
  • 48 produits par page : INP de 16 ms ou moins, presentation delay de 14 ms ou moins.

Le gestionnaire de clic prenait 1 ms dans chaque version : toute la différence venait du rendu. Avec l'un ou l'autre correctif, le tap ne prenait qu'une seule frame.

L'audit « Optimize DOM size » de Lighthouse liste les recalculs de style et les layouts qu'un DOM volumineux a ralentis ; comment réduire la taille du DOM détaille cet avertissement.

Travail dans les callbacks requestAnimationFrame et ResizeObserver

requestAnimationFrame s'exécute juste avant le rendu de la frame par le navigateur. Tout travail déplacé là depuis un gestionnaire de clic compte donc dans le presentation delay au lieu de la processing duration. Sur la page de test à 48 produits, Add to cart passe le bouton à « Added », puis exécute une fonction de tracking d'environ 90 ms :

  • Tracking dans le gestionnaire de clic : INP de 96 ms, dont 88 ms de processing duration.
  • Tracking dans requestAnimationFrame : INP de 104 ms, dont 103 ms de presentation delay.
  • Tracking dans un setTimeout à l'intérieur de requestAnimationFrame : INP de 16 ms ou moins, le tap n'a donc pris qu'une frame.

Dans requestAnimationFrame, le tap restait tout aussi lent : seule la partie à laquelle le travail est imputé a changé. Les callbacks de ResizeObserver s'exécutent dans la même étape de rendu, juste après le layout. Un slider ou une barre fixe qui se mesure ainsi ajoute donc son travail à chaque tap qui modifie sa taille.

Où voir le presentation delay pour chaque tap ?

Le presentation delay par interaction s'obtient via le Real User Monitoring : un outil de RUM comme CoreDash décompose chaque interaction lente en ses trois parties, par page et par élément tapé (CrUX et la Search Console ne fournissent que l'INP global). Une trace de ce tap dans les DevTools de Chrome montre ensuite ce qui s'est exécuté après le gestionnaire.

Dans CoreDash, ouvrez INP, Breakdown, filtrez sur mobile et groupez par Attribution Element : le bleu correspond à la présentation. En groupant plutôt par LoAF (les scripts dans les long animation frames), chaque ligne représente un script avec les trois parties des interactions dans lesquelles il est intervenu.

Décomposition de l'Interaction to Next Paint sur mobile dans CoreDash pour acme-pagespeed.com, sous-parties de l'INP par Attribution Element (INP) triées par p75 INP, chaque barre étant divisée en input delay (vert), processing (violet) et presentation (bleu) : button.view-toggle 368 ms avec 65 % de presentation ; button.filter-apply 304 ms et button.add-to-cart 236 ms avec le processing comme part principale à 58 % et 52 %, tous trois avec un point jaune ; button.menu-toggle 172 ms (presentation 40 %) et input.search-field 138 ms avec un point vert.

CoreDash sur acme-pagespeed.com, INP sur mobile par élément tapé : un élément dont la barre est majoritairement bleue attend après son gestionnaire, lors du rendu.

Dans les DevTools, enregistrez une trace du tap lent avec le CPU ralenti. L'insight INP breakdown affiche les trois parties. Dans la piste Main, tout ce qui se trouve après le gestionnaire d'événements constitue le presentation delay : Animation frame fired pour requestAnimationFrame, puis Recalculate style (cliquez dessus : Elements affected indique le nombre d'éléments recalculés), Layout et Paint. En activant « Enable CSS selector stats (slow) » dans les paramètres de capture, l'onglet Selector stats d'un Recalculate style montre quels sélecteurs l'ont ralenti. Le CPU throttling ne ralentit que le processeur : sur un vrai smartphone, le travail du GPU après le Paint peut donc prendre plus de temps que dans la trace.

Panneau Performance des DevTools Chrome après un tap sur Liste, enregistré pendant la trace, sur une page de test de catégorie avec 480 produits : l'insight INP breakdown indique un input delay de 6 ms, une processing duration de 1 ms et un presentation delay de 72 ms, et la piste Main montre Recalculate style, Layout, Pre-paint et Paint sous le presentation delay.

Le bouton Liste sur la page de test à 480 produits dans le panneau Performance, un tap avec la trace active : le gestionnaire prend 1 ms, et Recalculate style, Layout et Paint après lui forment le presentation delay.

Côté code, la version avec attribution de la bibliothèque web-vitals fournit les différentes parties pour chaque interaction :

import { onINP } from 'web-vitals/attribution';

onINP(({ value, attribution: a }) => {
  console.log('INP', value, {
    presentationDelay: Math.round(a.presentationDelay),
    styleAndLayout: Math.round(a.totalStyleAndLayoutDuration),
    paint: Math.round(a.totalPaintDuration),
    element: a.interactionTarget,
    longestScript: a.longestScript?.entry.sourceURL,
    scriptPart: a.longestScript?.subpart
  });
}, { reportAllChanges: true });

Lisez ces sous-parties depuis web-vitals ou DevTools, qui regroupent tous les événements d'un même tap. Une entrée Event Timing brute isole les choses différemment : l'entrée pointerup d'un tap comptabilise le gestionnaire de clic exécuté après elle dans son propre presentation delay. L'API Long Animation Frames indique quel script a allongé la frame, avec renderStart et styleAndLayoutStart pour marquer le début du rendu.

Comment réduire le presentation delay ?

Le presentation delay diminue quand chaque tap a moins à rendre : modifiez uniquement les éléments nécessaires, limitez la taille des longues listes ou laissez le navigateur ignorer le contenu hors écran, et gardez courts les callbacks d'animation frame et de ResizeObserver. Le travail invisible pour le visiteur doit passer après la frame. Partez de la ligne du tableau des causes ci-dessus qui correspond au tap lent constaté.

WordPress et les page builders

Dans Elementor, sous Réglages, Fonctionnalités, activez Optimized Markup et construisez avec des conteneurs plutôt qu'avec des sections et colonnes : les deux réduisent le nombre d'éléments wrappers autour de chaque widget. Vérifiez ensuite le CSS personnalisé : les sélecteurs écrits pour les anciens wrappers peuvent ne plus correspondre.

Affichez moins de produits par page (avec WooCommerce sur un thème classique : Apparence, Personnaliser, WooCommerce, Catalogue de produits, Lignes par page) et privilégiez la pagination à l'infinite scroll, qui conserve chaque produit chargé dans la page. Si cela ne suffit pas, demandez à un développeur d'enregistrer une trace du tap lent et de regarder combien d'éléments ont été touchés par son Recalculate style.

Shopify

Sur Shopify, commencez par la grille de produits. Dans l'éditeur de thème, le paramètre Produits par page de la section Grille de produits du modèle de collection définit le nombre de fiches affichées. Dans Dawn et les thèmes dérivés, l'application d'un filtre remplace toute la grille par du nouveau HTML et le navigateur re-rend chaque fiche : réduire le nombre de produits par page raccourcit donc aussi ce temps de rendu. Une application de type « charger plus » ou infinite scroll garde chaque produit chargé dans la page, et le moindre tap ultérieur modifiant la grille recalcule les styles de l'ensemble. Les applications qui ajoutent une barre d'ajout au panier fixe ou un slider peuvent injecter leurs propres scripts dans la frame après un tap : désactivez-les une par une et réenregistrez le tap. L'étape suivante pour un développeur consiste à appliquer content-visibility sur les fiches produits, comme expliqué ci-dessous.

Laisser le navigateur ignorer ce qui est hors écran

Avec content-visibility: auto, le navigateur ignore le style, le layout et le paint des éléments situés hors de l'écran tant que le visiteur ne scrolle pas à proximité. Sur la page de test ci-dessus, cette règle sur les fiches produits a suffi pour que le bouton Liste ne prenne qu'une frame :

.product-card {
  content-visibility: auto;
  contain-intrinsic-size: auto 330px;
}

Attribuez à chaque élément une propriété contain-intrinsic-size proche de sa hauteur réelle. Sans cela, une fiche ignorée mesure zéro pixel de haut et la barre de défilement saute au fil du rendu des fiches. Cette propriété fonctionne sous Chrome et Edge, sous Firefox depuis la version 125 et sous Safari depuis la version 18.

Modifier moins d'éléments à chaque tap

Placez la classe directement sur l'élément qui change : une classe posée sur <body> recalcule le style de chaque élément correspondant à ses règles, partout sur la page. Pour un menu ou un panneau de filtres, laissez le balisage dans la page et masquez-le avec display: none, bien moins coûteux que de réinjecter une liste complète à chaque tap. Le balisage masqué avec visibility ou opacity subit toujours le recalcul de style et de layout quand un tap modifie la page.

Un filtre, une liste ou un tiroir de panier ne doit rendre que ce qui a changé, et mettre à jour l'écran en priorité. Pour les longues listes, utilisez une pagination ou une liste virtualisée qui ne conserve dans le DOM que les lignes visibles à l'écran.

Sortir le travail de la frame

Le gestionnaire de clic n'effectue que le changement visible ; tout ce que le visiteur ne voit pas, comme le tracking, va dans un setTimeout déclenché depuis un callback requestAnimationFrame, afin de s'exécuter après le paint de la frame :

button.addEventListener('click', () => {
  button.textContent = 'Added'; // ce que le visiteur voit
  requestAnimationFrame(() => {
    setTimeout(sendTracking, 0); // s'exécute après la frame
  });
});

requestAnimationFrame seul s'exécute avant la frame : voilà pourquoi le tracking de la mesure Add to cart ci-dessus est resté comptabilisé dans le tap. Limitez les callbacks de ResizeObserver au strict nécessaire en lecture et écriture. Animez avec les propriétés CSS transform et opacity, sans script tournant à chaque frame : abandonner le scrolling JavaScript explique comment faire pour le défilement fluide. Pour les événements Google Tag Manager, planifier les événements dataLayer applique le même pattern.

React, Vue et autres frameworks

Certaines Single Page Applications re-rendent bien trop de contenu après chaque interaction. Les mises à jour du DOM effectuées par le framework comptent dans la processing duration ; le rendu de ces changements relève du presentation delay. Dans les React DevTools, « Highlight updates when components render » montre tout ce qu'un clic rend.

React.memo évite de re-rendre les composants dont les props n'ont pas changé. Avec startTransition ou useDeferredValue, React rend la partie lourde après la frame, en dehors de l'interaction. Sous React, @tanstack/react-virtual permet de virtualiser une longue liste.

Le tap est-il plus rapide après la modification ?

Enregistrez à nouveau le même tap avec le même réglage de CPU : la décomposition de l'INP montre un presentation delay plus court, et le long Recalculate style ou Layout a disparu. Pour les vrais visiteurs, la part de présentation de cet élément chute dans CoreDash quelques jours après la modification, tandis que la Search Console met jusqu'à 28 jours.

Une fois le rendu allégé, l'interaction la plus lente peut devenir un autre tap, affecté par un input delay ou une processing duration importants. Vérifiez à nouveau les trois parties ; le guide étape par étape de l'INP part du rapport de la Search Console pour remonter jusqu'au tap lent.

Parfois, la frame lente provient d'un thème, d'un page builder ou d'une application impossible à modifier, ou bien la trace révèle un rendu qu'on ne parvient pas à relier à une classe ou un script. Lors d'une Core Web Vitals power hour, nous enregistrons ce tap ensemble sur votre page pour trouver ce qui force le navigateur à faire autant de rendu.

About the author

Arjen Karel is a web performance consultant and the creator of CoreDash, a Real User Monitoring platform that tracks Core Web Vitals data across hundreds of sites. He also built the Core Web Vitals Visualizer Chrome extension. He has helped clients achieve passing Core Web Vitals scores on over 925,000 mobile URLs.

Arjen Karel

Besoin d'un site plus rapide ?

Je suis Arjen et je répare des sites lents depuis 17 ans. Si vous rencontrez des problèmes que vous ne pouvez pas résoudre vous-même, envoyez-moi votre URL et parlons-en.

Envoyez-moi votre URL
Arjen Karel
Arjen Karel, Consultant en performance web depuis 2009

Pourquoi notre fix ne fonctionne pas ?

Parfois le CDN sert encore l'ancien HTML, ou le fix a été appliqué sur le template desktop alors que le mobile en utilise un autre. Envoyez-moi votre URL et le problème, et je vous réponds avec quelques créneaux. J'analyse d'abord vos field data, puis nous passons une heure sur votre site, et sous 24 heures vous avez mes notes par écrit. 350 € HT.

Envoyez-moi votre URL

Pas de développeur pour réaliser le fix ? Je fais le travail moi-même, sur une copie de votre site.

Arjen KarelINP encore rouge sur mobile ?Envoyez-moi votre URL