Pourquoi l’INP change la manière d’optimiser une interface

Pendant longtemps, beaucoup d’optimisations frontend se concentraient sur le chargement initial : réduire le poids des images, compresser les assets, différer le JavaScript, améliorer le Largest Contentful Paint. Ces sujets restent essentiels, comme on le voit avec l’optimisation des images web, les resource hints HTML ou la compression HTTP. Mais une page rapide à afficher peut rester désagréable si elle répond lentement aux actions de l’utilisateur.

C’est précisément le rôle de l’INP, pour Interaction to Next Paint. Cette métrique des Core Web Vitals mesure le temps entre une interaction utilisateur et le prochain rendu visible de la page. Elle prend en compte les clics, les pressions clavier et les interactions tactiles. En pratique, elle répond à une question simple : quand l’utilisateur agit, combien de temps l’interface met-elle à réagir visuellement ?

Un mauvais INP ne vient pas forcément d’un serveur lent. Il est souvent causé par un thread principal saturé : trop de JavaScript synchrone, trop de calculs pendant un événement, trop de rendu inutile, ou une architecture qui déclenche de grosses mises à jour au moindre clic.

Comprendre le chemin critique d’une interaction

Une interaction lente suit généralement trois étapes :

  1. Le navigateur reçoit l’événement, par exemple un click.
  2. Le JavaScript associé s’exécute.
  3. Le navigateur peut enfin recalculer les styles, le layout, puis peindre l’état suivant.

Si votre gestionnaire d’événement bloque le thread principal pendant 300 ms, l’utilisateur ne verra aucun retour visuel pendant ce délai. Même si le code est correct fonctionnellement, l’expérience paraît lourde.

Voici un exemple typique de code problématique :

button.addEventListener('click', () => {
  const result = computeLargeReport(items);
  renderChart(result);
  savePreferences();
});

Tout est exécuté immédiatement, dans la même tâche JavaScript. Si computeLargeReport est coûteux, le navigateur ne peut pas peindre un état intermédiaire comme un bouton désactivé, un spinner ou un message de progression.

Une première amélioration consiste à séparer le retour visuel immédiat du travail non urgent :

button.addEventListener('click', () => {
  button.disabled = true;
  button.textContent = 'Calcul en cours...';

  requestAnimationFrame(() => {
    const result = computeLargeReport(items);
    renderChart(result);
    button.textContent = 'Terminé';
  });
});

Cette version n’est pas parfaite, car le calcul reste synchrone, mais elle laisse au moins au navigateur une occasion d’afficher le changement d’état avant de commencer le traitement lourd.

Mesurer avant d’optimiser

Pour améliorer l’INP, il faut d’abord identifier quelles interactions sont lentes. Les outils de laboratoire, comme Lighthouse ou Chrome DevTools, sont utiles, mais ils ne remplacent pas les mesures en conditions réelles. Une interface peut être fluide sur une machine de développeur et lente sur un téléphone d’entrée de gamme.

Vous pouvez compléter vos mesures avec PerformanceObserver, déjà utile pour suivre les lenteurs frontend en production comme expliqué dans l’article sur PerformanceObserver.

const observer = new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    console.log({
      name: entry.name,
      duration: entry.duration,
      startTime: entry.startTime
    });
  }
});

observer.observe({
  type: 'event',
  buffered: true,
  durationThreshold: 40
});

Selon les navigateurs et les versions, les entrées disponibles peuvent varier. Il faut donc traiter cette mesure comme un signal d’observation progressive, pas comme une dépendance critique de l’application.

Une bonne collecte de performance doit aussi éviter de tout envoyer au serveur. Échantillonnez les données, anonymisez les informations sensibles et conservez uniquement les éléments utiles : type d’interaction, durée, page, composant concerné, contexte matériel approximatif.

Découper les tâches longues

Une cause fréquente de mauvais INP est la tâche longue. Une tâche JavaScript longue empêche le navigateur de traiter les événements suivants et de repeindre l’interface. Si une opération prend 200 ms, essayez de la découper en plusieurs morceaux.

async function processInChunks<T>(
  items: T[],
  process: (item: T) => void,
  chunkSize = 100
) {
  for (let index = 0; index < items.length; index += chunkSize) {
    const chunk = items.slice(index, index + chunkSize);

    for (const item of chunk) {
      process(item);
    }

    await new Promise<void>((resolve) => {
      setTimeout(resolve, 0);
    });
  }
}

Ce code laisse régulièrement la main au navigateur. Pour des cas plus avancés, vous pouvez utiliser la Scheduler API, qui permet de prioriser certaines tâches avec scheduler.postTask, ou déplacer les traitements coûteux dans des Web Workers lorsque le calcul n’a pas besoin d’accéder directement au DOM.

await scheduler.postTask(
  () => updateSearchIndex(documents),
  { priority: 'background' }
);

La règle générale est simple : ce qui produit un feedback utilisateur immédiat doit rester prioritaire ; ce qui prépare, synchronise, indexe ou enrichit peut souvent attendre.

Réduire le travail dans les gestionnaires d’événements

Un gestionnaire d’événement devrait faire le minimum nécessaire. Il peut valider l’action, mettre à jour un état visuel immédiat, puis déléguer le reste.

Dans une interface de recherche, par exemple, il est tentant de filtrer une grande liste à chaque frappe :

input.addEventListener('input', () => {
  const results = allProducts.filter((product) => {
    return product.name.toLowerCase().includes(input.value.toLowerCase());
  });

  renderResults(results);
});

Sur une petite liste, cela passe inaperçu. Sur plusieurs milliers d’éléments, chaque frappe peut devenir coûteuse. Une version plus robuste combine limitation de fréquence, annulation et rendu progressif.

let timeoutId: number | undefined;

input.addEventListener('input', () => {
  window.clearTimeout(timeoutId);

  timeoutId = window.setTimeout(() => {
    const query = input.value.trim().toLowerCase();
    const results = searchProducts(query);
    renderResults(results.slice(0, 50));
  }, 120);
});

Pour les requêtes réseau déclenchées par une recherche dynamique, pensez aussi à AbortController, afin d’annuler les anciennes requêtes au lieu de les laisser se terminer dans le désordre. Le sujet est détaillé dans AbortController en JavaScript.

Exemple Vue : différer un filtrage coûteux

Voici un exemple Vue volontairement simple. L’objectif est de distinguer la saisie immédiate de la recherche calculée.

<script setup lang="ts">
import { ref, watch } from 'vue';

type Product = {
  id: string;
  name: string;
  category: string;
};

const query = ref('');
const products = ref<Product[]>([]);
const results = ref<Product[]>([]);
const isFiltering = ref(false);

let timeoutId: number | undefined;

watch(query, (value) => {
  window.clearTimeout(timeoutId);
  isFiltering.value = true;

  timeoutId = window.setTimeout(() => {
    const normalized = value.trim().toLowerCase();

    results.value = products.value
      .filter((product) => {
        return product.name.toLowerCase().includes(normalized);
      })
      .slice(0, 100);

    isFiltering.value = false;
  }, 120);
});
</script>

<template>
  <label>
    Rechercher
    <input v-model="query" type="search" />
  </label>

  <p v-if="isFiltering" role="status">Mise à jour des résultats...</p>

  <ul>
    <li v-for="product in results" :key="product.id">
      {{ product.name }}
    </li>
  </ul>
</template>

Le message avec role="status" aide aussi les technologies d’assistance à comprendre qu’un changement dynamique est en cours. Pour aller plus loin sur ce point, consultez l’article consacré aux ARIA live regions.

Attention aux rendus inutiles

L’INP n’est pas seulement une affaire de JavaScript pur. Un gestionnaire d’événement peut être rapide, mais déclencher ensuite un rendu très coûteux. Quelques causes fréquentes :

  • mettre à jour un état global alors qu’un état local suffit ;
  • recalculer une liste complète pour une modification minime ;
  • modifier des classes qui forcent un recalcul de layout massif ;
  • lire puis écrire dans le DOM en boucle ;
  • recréer des composants lourds au lieu de préserver leur état.

Dans les interfaces complexes, les techniques d’architecture comptent autant que les micro-optimisations. Une machine à états peut éviter des combinaisons d’états incohérentes, comme expliqué dans Machines à états en TypeScript. Un cache frontend bien conçu peut aussi limiter des recalculs et rechargements inutiles, comme dans l’approche stale-while-revalidate.

Donner un feedback immédiat

Optimiser l’INP ne signifie pas uniquement réduire des durées mesurées. Il faut aussi améliorer la perception. Un bouton qui change immédiatement d’état paraît plus réactif, même si le traitement complet prend encore quelques centaines de millisecondes.

async function submitForm() {
  submitButton.disabled = true;
  submitButton.textContent = 'Envoi...';

  try {
    await sendForm();
    showSuccessMessage();
  } catch {
    showErrorMessage();
  } finally {
    submitButton.disabled = false;
    submitButton.textContent = 'Envoyer';
  }
}

Ce feedback doit rester accessible : texte visible, état disabled réel, message d’erreur compréhensible, focus correctement géré. Les performances ne doivent jamais se faire au détriment de l’accessibilité.

Une stratégie pragmatique pour améliorer l’INP

Commencez par les interactions les plus fréquentes : ouverture de menu, recherche, ajout au panier, validation de formulaire, changement de filtre, navigation interne. Mesurez-les sur des appareils modestes, puis cherchez les tâches longues dans DevTools.

Ensuite, appliquez les corrections dans cet ordre : réduire le travail synchrone, donner un feedback immédiat, découper les tâches longues, déplacer les calculs lourds hors du thread principal, puis limiter les rendus inutiles.

L’INP rappelle une réalité fondamentale du frontend : une interface n’est pas seulement un document à charger, c’est un système interactif. Une bonne performance web ne se juge donc pas uniquement au moment où la page apparaît, mais aussi à chaque fois que l’utilisateur essaie de s’en servir.