Interaction to Next Paint (INP): Was er ist, wie du ihn misst und verbesserst
Was der INP misst, wie er sich vom FID unterscheidet und welche der drei Phasen du zuerst behebst.
Interaction to Next Paint (INP) ist ein Core Web Vital, der misst, wie schnell eine Webseite auf Nutzerinteraktionen wie Klicks, Taps und Tastendrücke reagiert. Der INP erfasst die gesamte Latenz von der Nutzereingabe über die JavaScript-Verarbeitung bis zum finalen visuellen Update auf dem Bildschirm. Ein guter INP-Wert liegt beim 75. Perzentil bei 200 Millisekunden oder weniger. Im März 2024 hat der INP den First Input Delay (FID) als Core Web Vital abgelöst.
Table of Contents!
- Was ist Interaction to Next Paint (INP)?
- INP vs. FID: Was sich geändert hat und warum
- Welche Interaktionen misst der INP?
- Die drei Phasen einer INP-Interaktion
- Was sind gute und schlechte INP-Werte?
- So misst du Interaction to Next Paint (INP)
- So verbesserst du Interaction to Next Paint
- INP mit der Long Animation Frames (LoAF) API debuggen
- Fallstudien: INP-Verbesserungen in der Praxis
- Was CoreDash-Daten über den INP zeigen
- Häufig gestellte Fragen (FAQ)
- Weiterführende Leitfäden
Was ist Interaction to Next Paint (INP)?
Der INP ist der Core Web Vital für Reaktionsfähigkeit. Er betrachtet jede Interaktion während eines Besuchs und liefert eine einzige Zahl für die Seite.
Bei jedem Klick, Tap oder Tastendruck misst der Browser die Zeit von der Eingabe bis zum nächsten Frame auf dem Bildschirm. Die langsamste Interaktion wird zum INP dieses Besuchs. Auf Seiten, auf denen Nutzer viel klicken, ignoriert Chrome einen Ausreißer pro 50 Interaktionen. Das entspricht ungefähr dem 98. Perzentil.
INP vs. FID: Was sich geändert hat und warum
Im März 2024 hat der INP den First Input Delay (FID) offiziell als Core Web Vital abgelöst. Google hat den FID eingestellt, weil zwei entscheidende Aspekte fehlten.
Erstens maß der FID nur die erste Interaktion auf einer Seite. War der erste Klick eines Nutzers schnell, spätere Interaktionen aber langsam, meldete der FID trotz der schlechten Nutzererfahrung ein Bestehen. Der INP misst jede Interaktion während des gesamten Besuchs.
Zweitens erfasste der FID ausschließlich die Phase des Input Delays – also die Zeit, die der Browser wartete, bevor er mit der Verarbeitung des Events begann. Die Ausführungszeit der Event-Handler (Processing Time) und die Zeit bis zum Zeichnen des Ergebnisses auf dem Bildschirm (Presentation Delay) ignorierte er komplett. Der INP misst alle drei Phasen.
| Aspekt | First Input Delay (FID) | Interaction to Next Paint (INP) |
|---|---|---|
| Status | Eingestellt (März 2024) | Aktiver Core Web Vital |
| Gemessene Interaktionen | Nur die erste Interaktion | Alle Interaktionen der gesamten Sitzung |
| Erfasste Phasen | Nur Input Delay | Input Delay + Processing Time + Presentation Delay |
| Schwellenwert für „Gut“ | 100 ms | 200 ms |
| Ermittlung des Messwerts | Verzögerung der ersten Eingabe | Langsamste Interaktion (ein Ausreißer pro 50 Interaktionen wird übersprungen) |
Fast jede Website hat den FID bestanden. Viele fallen beim INP durch, weil spätere Interaktionen oder die anfallende Arbeit nach dem ersten Klick schlicht zu langsam sind.
Welche Interaktionen misst der INP?
Der INP erfasst ausschließlich diskrete Interaktionen: einen Klick, einen Tap oder einen Tastendruck.
Interaktionen, die für den INP zählen
- Mausklicks (einschließlich Klicks auf Buttons, Links, Checkboxen und eigene Steuerelemente)
- Taps auf Touchscreens (entspricht Klicks auf Mobilgeräten)
- Tastendrücke auf einer physischen Tastatur oder Bildschirmtastatur (einschließlich Tippen in Formularfeldern, Drücken der Enter-Taste, Tastaturkürzel)
Interaktionen, die NICHT für den INP zählen
- Scrollen (siehe unten)
- Hovern (Mouseover)
- Dragging, obwohl das pointerdown, das den Drag-Vorgang startet, gemessen werden kann
- CSS-Transitionen und -Animationen, die ohne Nutzereingabe ablaufen
Scrollen selbst zählt nicht. Scroll-Code kann den INP trotzdem auf zwei Arten verschlechtern: Ein Klick auf einen Anker-Link, der eine JavaScript-Scroll-Animation auslöst, ist eine Interaktion – und der Scroll-Code läuft direkt darin. Zudem halten Scroll-Handler, die bei jedem Scroll-Event feuern, den main thread beschäftigt, sodass der nächste Klick warten muss. scroll-behavior: smooth in CSS verhindert beides.
Die drei Phasen einer INP-Interaktion
Jede vom INP gemessene Interaktion durchläuft nacheinander drei Phasen (Google nennt sie Subparts). Der INP-Wert ist die Summe aller drei Phasen, und jede Phase erfordert einen anderen Fix.

1. Input Delay
Der Input Delay ist die Zeit zwischen dem Klick und dem Start der Event-Handler. Der Klick muss auf jeden Task warten, der in diesem Moment auf dem main thread läuft: ein Tag Manager, das Skript eines Consent-Banners oder ein Framework, das noch hydriert.
Der Input Delay ist am größten, während die Seite noch lädt. Nach Daten von CoreDash sind Klicks während des Ladevorgangs mehr als doppelt so langsam wie Klicks nach dem Laden (Zahlen dazu weiter unten).
2. Processing Time
Die Processing Time ist die Zeit, die die Event-Handler für die Ausführung der Interaktion brauchen: Formularvalidierung, ein State-Update, ein Analytics-Aufruf.
Führt ein Event-Handler aufwendige DOM-Operationen, synchrone API-Aufrufe oder langsame Schleifen aus, steigt die Processing Time. Ein Klassiker: ein dataLayer.push() im Click-Handler, sodass jeder Tag im Tag Manager abgearbeitet wird, bevor der Bildschirm aktualisieren kann. Der Fix: vor dem Push yielden.
3. Presentation Delay
Der Presentation Delay ist die Zeit vom Ende der Event-Handler bis zum nächsten Frame auf dem Bildschirm: Style, Layout, Paint.
Seiten mit einem großen oder tief verschachtelten DOM brauchen länger, um Styles neu zu berechnen und das Layout durchzuführen. Single-Page-Applications, die nach einer Statusänderung riesige Komponentenbäume neu rendern, weisen oft einen hohen Presentation Delay auf.
Was sind gute und schlechte INP-Werte?
Um zu bestehen, muss der INP deiner Seitenbesuche bei p75 bei 200 Millisekunden oder weniger liegen:
- Ein INP von 200 Millisekunden oder weniger bedeutet, dass deine Seite eine gute Reaktionsfähigkeit hat.
- Ein INP zwischen 200 und 500 Millisekunden bedeutet, dass die Reaktionsfähigkeit deiner Seite verbessert werden muss.
- Ein INP über 500 Millisekunden bedeutet, dass deine Seite eine schlechte Reaktionsfähigkeit hat.

Der INP nutzt das 75. Perzentil: 75 % der Seitenbesuche müssen einen INP unter 200 ms erreichen. Das schließt Besucher auf langsamen Smartphones voll ein.
So misst du Interaction to Next Paint (INP)
Der INP benötigt echte Besucher, die klicken, tippen und interagieren. Der INP, auf den es ankommt, stammt daher aus field data. Ein Lab-Test, der die Seite nur lädt, liefert keinen INP. Lighthouse zeigt stattdessen die Total Blocking Time. Sie verrät dir, wie blockiert der main thread beim Laden ist – sagt dir aber nichts über den Klick auf dein Filtermenü.
Offizielle INP-Metriken abrufen
Der offizielle INP stammt aus dem CrUX. PageSpeed Insights zeigt das 75. Perzentil der letzten 28 Tage an Chrome-Daten für eine URL oder einen Origin. CrUX Vis visualisiert den Verlauf der letzten Monate, und CrUX auf BigQuery liefert die monatlichen Rohdaten für jeden Origin.
Die Google Search Console gruppiert deine URLs im Core-Web-Vitals-Bericht. Eine durchfallende Gruppe taucht als „INP-Problem: länger als 200 ms (Mobilgeräte)“ oder „INP-Problem: länger als 500 ms (Mobilgeräte)“ auf, inklusive Beispiel-URLs. Der Bericht umfasst die letzten 28 Tage. Zwei Wochen nachdem ein Fix live geht, spiegelt die Hälfte der Daten immer noch die alte Website wider.
INP mit Real User Monitoring tracken
Der CrUX meldet dir nur, dass eine Seitengruppe durchfällt. Welcher Button das Problem verursacht, erfährst du dort nicht. Dafür brauchst du Real User Monitoring. In CoreDash analysiere ich zuerst den mobilen INP p75, aufgeschlüsselt nach dem geklickten Element und dem Ladezustand.
INP für die aktuelle Sitzung messen
Öffne das Performance-Panel in den Chrome DevTools. Es zeigt dir beim Durchklicken den INP deiner aktuellen Sitzung, inklusive Protokoll jeder einzelnen Interaktion und ihrer drei Phasen. Nimm einen Trace auf, während du klickst, um exakt zu sehen, was auf dem main thread lief. Die Browser-Erweiterung Core Web Vitals Visualizer blendet den INP direkt auf der Seite ein.
Für direktes Debugging nutzt du die Web Vitals JavaScript Library von Google, um einzelne Interaktionen in der Konsole zu loggen:
INP mit der Web Vitals JavaScript Library in der Konsole loggen
<script type="module">
import {onINP}
from 'https://unpkg.com/web-vitals@6/dist/web-vitals.attribution.js?module';
onINP(console.log);
</script>
So verbesserst du Interaction to Next Paint
Eine einzige langsame Interaktion kann den INP des gesamten Besuchs ruinieren, selbst wenn jeder andere Klick blitzschnell ist. Arbeite die drei Phasen systematisch ab.
PageSpeed-Tipp: Logge den Ladezustand der Seite bei jeder Interaktion mit. Ein langsamer Klick während des Ladens erfordert einen völlig anderen Fix als ein langsamer Klick auf einer fertig geladenen Seite.
1. Input Delay minimieren: Long Tasks auf dem main thread verhindern
Die meiste Arbeit auf dem main thread fällt beim Seitenstart an. Halte ihn frei:
- Ungenutzten Code entfernen. Das Coverage-Panel in den DevTools zeigt dir, wie viel Prozent jedes Skripts nie ausgeführt werden. Tree-Shaking und Code-Splitting erledigen den Rest.
- Nicht-kritischen Code im Browser-Leerlauf laden. Brauchst du in den ersten 500 ms nach dem Start wirklich ein Chat-Widget? Plane unkritische Skripte mit
requestIdleCallback()so ein, dass sie erst laufen, wenn der Browser Leerlauf hat. - Finde den Long Task unter dem Klick. Nimm im Performance-Panel einen Trace auf, während du beim Laden klickst. Der Task, der in genau dem Moment läuft, in dem dein Klick ankommt, muss zuerst angegangen werden.
- Nutze async und defer bei Script-Tags, damit JavaScript den HTML-Parser nicht blockiert. Skripte, die in den ersten Sekunden niemand braucht, können warten: 14 Methoden, um JavaScript aufzuschieben.
- Spar dir den Ratschlag zu passiven Listenern.
{ passive: true }wird oft für den INP empfohlen. Es macht lediglich das Scrollen flüssiger. Dem INP ist das völlig egal.
Long Tasks mit scheduler.yield() aufbrechen
JavaScript läuft auf dem main thread des Browsers nach einem „Run-to-Completion“-Modell: Sobald ein Task startet, blockiert er den main thread bis zum Ende. Long Tasks (über 50 ms) hindern den Browser daran, zeitnah auf Nutzereingaben zu reagieren. Mit scheduler.yield() gibst du dem Browser kurz Zeit, einen wartenden Klick abzuarbeiten, bevor dein Code fortfährt. Mehr dazu unter an den main thread yielden.
async function yieldToMain() {
if ('scheduler' in window && 'yield' in window.scheduler) {
return await window.scheduler.yield();
}
// Fallback for browsers without scheduler.yield()
return new Promise((resolve) => {
setTimeout(resolve, 0);
});
}
// Usage: break up a long task into smaller chunks
async function processLargeDataSet(items) {
for (let i = 0; i < items.length; i++) {
processItem(items[i]);
// Yield every 5 items to let the browser handle user input
if (i % 5 === 0) {
await yieldToMain();
}
}
} Unkritische Aufgaben mit requestIdleCallback aufschieben
Nutze requestIdleCallback(), um unkritische Tasks (Analytics, Telemetrie, Prefetching) in den Leerlauf des Browsers zu verschieben. So tauchen sie gar nicht erst in der Processing Time des Klicks auf.
// Instead of running analytics synchronously:
document.querySelector('.cta-button').addEventListener('click', (e) => {
// Critical: update the UI immediately
showConfirmation();
// Non-critical: send analytics during idle time
requestIdleCallback(() => {
sendAnalyticsEvent('cta_clicked', { page: location.pathname });
}, { timeout: 2000 });
}); 2. Processing Time minimieren: Sofortiges Feedback liefern
Führt ein Besucher eine Aktion wie das Absenden eines Formulars oder das Hinzufügen eines Artikels zum Warenkorb aus, warte keinesfalls auf die Bestätigung des Servers, bevor du die UI aktualisierst. Gib sofort visuelles Feedback („Formular wird gesendet ...“, „Artikel wird in den Warenkorb gelegt ...“) und führe die eigentliche Operation im Hintergrund aus.
Yielde außerdem so schnell wie möglich nach dem kritischen visuellen Update an den main thread. Da JavaScript einem „Run-to-Completion“-Modell folgt, blockiert es den main thread, bis sämtlicher Code im Callback abgearbeitet ist. Erzeuge manuell einen Yield-Punkt, an dem der Browser das Layout aktualisieren kann, bevor der verbleibende unkritische Code läuft.
const formfeedbackEl = document.getElementById("formfeedback");
const formEl = document.getElementById("form");
formEl.addEventListener("submit", (evt) => {
evt.preventDefault();
formfeedbackEl.innerText = "Submitting form ... please hold on";
let headers = new Headers({ Accept: "application/json" });
let formData = new FormData(formEl);
fetch("/form-endpoint", { method: "POST", headers, body: formData })
.then(function (response) {
return response.json();
})
.then(function (jsonData) {
formEl.reset();
formfeedbackEl.innerText = jsonData.message;
});
setTimeout(other_code_that_needs_to_run, 0);
}); 3. Presentation Delay minimieren: Halte es einfach
Muss sich die Seite nach einer Interaktion aktualisieren, muss der Browser Styles neu berechnen, das Layout durchführen, die veränderten Pixel zeichnen und das Ergebnis zusammenfügen. Die Komplexität und Größe deines DOM bestimmen direkt, wie lange dieses Rendering dauert.
Manche Single-Page-Applications rendern nach jeder Interaktion die halbe Seite neu, obwohl sich nur ein simpler Zähler geändert hat. React DevTools und React Scan decken das schonungslos auf. Oft reicht ein einziger Context Provider weit oben im Komponentenbaum, der bei jeder Änderung alles unter sich neu rendert.
Zwei Regeln für schnelleres Rendering:
- Halte das DOM klein und flach. Ein kleines, flaches DOM rendert erheblich schneller als ein großes, tief verschachteltes. Lighthouse markiert Seiten mit mehr als 1.400 DOM-Elementen oder einer Verschachtelungstiefe von mehr als 32 Ebenen als problematisch.
- Nutze content-visibility für Lazy Rendering von Off-Screen-Inhalten. Die CSS-Eigenschaft
content-visibility: autobeschleunigt das initiale Rendering, indem sie das Rendern von Inhalten außerhalb des Viewports aufschiebt, bis der Nutzer in ihre Nähe scrollt.
/* Apply content-visibility to off-screen sections */
.below-the-fold {
content-visibility: auto;
contain-intrinsic-size: auto 500px;
} INP mit der Long Animation Frames (LoAF) API debuggen
Die Long Animation Frames (LoAF) API liefert dir präzise Details zu Frames, deren Rendering länger als 50 ms dauert – inklusive der Information, welche Skripte in dieser Zeit liefen.
Anders als die veraltete Long Tasks API erfasst LoAF sowohl die Rendering-Dauer als auch die Skriptausführungszeit. Das macht sie ideal, um Presentation-Delay-Engpässe zu diagnostizieren. Jeder Eintrag enthält die gesamte Frame-Dauer sowie die blockierende Zeit. Die Skriptliste schlüsselt pro Skript Quell-URL, Funktionsnamen und Laufzeit auf.
// Observe Long Animation Frames to find INP bottlenecks
const observer = new PerformanceObserver((list) => {
for (const entry of list.getEntries()) {
// Only look at frames longer than 100ms
if (entry.duration > 100) {
console.log('Long frame:', entry.duration + 'ms');
// Log each script that contributed
for (const script of entry.scripts) {
console.log(
'Script:', script.sourceURL,
'Function:', script.sourceFunctionName,
'Duration:', script.duration + 'ms'
);
}
}
}
});
observer.observe({ type: 'long-animation-frame', buffered: true }); RUM-Tools wie CoreDash integrieren LoAF-Daten automatisch und verknüpfen Long Animation Frames mit konkreten Nutzerinteraktionen. So siehst du auf einen Blick, welches Skript auf welcher Seite welche Interaktion verlangsamt.
INP und LCP: Die Verbindung über Long Tasks
Long Tasks auf dem main thread beeinträchtigen sowohl den INP als auch den Largest Contentful Paint (LCP). Ein JavaScript-Task, der den main thread 200 ms lang blockiert, verzögert die Verarbeitung von Events (was den INP verschlechtert) und hindert den Browser zugleich daran, das LCP-Element darzustellen (was den LCP verschlechtert). Optimierst du den main thread, indem du Long Tasks aufbrichst, unkritisches JavaScript aufschiebst und Ausführungszeiten senkst, verbesserst du beide Metriken auf einen Schlag.
Fallstudien: INP-Verbesserungen in der Praxis
redBus: INP um 72 % gesenkt, Umsatz um 7 % gesteigert
redBus, eine Online-Plattform für Bustickets, stieß in ihren RUM-Daten auf unerwartet langsame Interaktionen. Auf der Suchseite feuerten Scroll-Handler bei jedem Scroll-Event und blockierten den main thread – die Entwickler haben sie daraufhin gedebounced. Auf einer anderen Seite rief jede Tastatureingabe im Eingabefeld den State Reducer auf; auch diese Aufrufe wurden gedrosselt. Der INP dieser Seite verbesserte sich um 72 %, und redBus verzeichnete ein Umsatzplus von rund 7 %. (redBus-Fallstudie auf web.dev)
Preply: INP von 250 ms auf 185 ms auf einer Next.js-Website
Preply, eine Plattform für Online-Sprachunterricht auf Next.js-Basis, senkte den INP der Startseite von rund 250 ms auf 185 ms und den der Suchseite auf 175 ms – ganz ohne React Server Components. Sie virtualisierten eine lange Liste, debouncten Tastatur-Events, memoisierten aufwendige Komponenten, verhinderten, dass ein Tooltip die komplette Seite neu renderte, und bereinigten das State-Handling ihres Privacy-Banners. Vor dem Projekt schätzte das Team den Wert eines INP unter 200 ms auf beiden Seiten auf rund 200.000 Dollar pro Jahr an zusätzlichem Search-Traffic. (Preply-Engineering-Blog)
Was CoreDash-Daten über den INP zeigen
Die INP-Kluft zwischen Mobilgeräten und Desktop
In den CoreDash-Daten ist der mobile INP (131 ms bei p75) 2,8-mal so hoch wie der Desktop-INP (48 ms). Smartphones besitzen langsamere Prozessoren. Dasselbe JavaScript blockiert den main thread deutlich länger. Auf dem Desktop sind 95,6 % der Interaktionen gut, mobil nur 88,0 % – und Smartphones verzeichnen fünfmal so viele schlechte Interaktionen (9,6 % gegenüber 1,9 %).
Tastatur- vs. Pointer-Interaktionen
CoreDash-Daten belegen, dass Tastatur-Interaktionen (75 ms bei p75) 56 % langsamer sind als Pointer-Interaktionen (49 ms bei p75). Tastatur-Events führen zudem rund fünfmal häufiger zu einer schlechten Erfahrung: 7,4 % der Tastatur-Interaktionen enden in einem schlechten INP, verglichen mit lediglich 1,4 % bei Pointer-Interaktionen. Tastatur-Events, gerade in Formularfeldern, triggern häufig synchrone Validierungen, Autocomplete und State-Updates.
Interaktionen während des Ladens vs. nach dem Laden
Interaktionen während des Seitenaufbaus haben einen drastisch schlechteren INP als Interaktionen nach Abschluss des Ladens. Laut CoreDash-Daten liegt der p75-INP bei Interaktionen in der „loading“-Phase bei 132 ms, verglichen mit nur 50 ms nach dem Laden. Das ist ein Unterschied um den Faktor 2,6. Selbst Interaktionen während der „dom-content-loaded“-Phase (75 ms) zeigen stark erhöhte Werte, weil asynchrone Skripte und Subressourcen noch verarbeitet werden. Die Lösung lautet weniger JavaScript beim Seitenstart: schiebe auf, was warten kann.
INP im gesamten Web
Im CrUX-Release vom August 2026 wiesen 85,3 % aller Origins einen guten INP auf – ein spürbarer Rückgang gegenüber 87,2 % im März. In jedem einzelnen Monat dazwischen sank der INP. Er ist der einzige Core Web Vital, der schlechter abschnitt als im August 2025 (85,7 %). Das Chrome-Team bezeichnet dies als besorgniserregend und hat bislang keine Erklärung dafür.
Der Web Almanac 2025 verdeutlicht die Kluft zwischen den Gerätetypen: 97 % der Desktop-Seiten erreichen einen guten INP, aber nur 77 % auf Mobilgeräten. Die Top-1.000-Websites verbesserten sich am stärksten: von 53 % auf 63 % gute Werte auf Mobilgeräten. Gleichzeitig stieg die mediane mobile Total Blocking Time um 58 % an – von 1.209 auf 1.916 Millisekunden.
Häufig gestellte Fragen (FAQ)
Was ist ein guter INP-Wert?
Ein guter INP liegt für mindestens 75 % der Seitenbesuche bei 200 Millisekunden oder weniger. Zwischen 200 und 500 ms muss der Wert verbessert werden. Werte über 500 ms gelten als schlecht. Google nutzt exakt diese Schwellenwerte bei der Core-Web-Vitals-Bewertung, und diese Bewertung fließt direkt als Ranking-Signal ein.
Was hat den First Input Delay (FID) abgelöst?
Interaction to Next Paint (INP) hat den First Input Delay (FID) im März 2024 als Core Web Vital abgelöst. Der FID maß lediglich den Input Delay der ersten Interaktion. Der INP misst jede Interaktion während eines Besuchs – von der Eingabe bis zum nächsten gerenderten Frame auf dem Bildschirm.
Beeinflusst Scrollen den INP?
Nein. Der INP misst ausschließlich Klicks, Taps und Tastendrücke. Schlechter Scroll-Code kann ihn dennoch beeinträchtigen: Ein Klick auf einen Anker-Link, der eine JavaScript-Scroll-Animation auslöst, ist eine Interaktion. Und Scroll-Handler, die bei jedem Scroll-Event feuern, blockieren den main thread, wenn der nächste Klick ankommt. CSS scroll-behavior: smooth verhindert beides.
Welche Interaktionen misst der INP?
Der INP misst Klicks, Taps und Tastendrücke, einschließlich des Tippens in Formularfeldern. Scrollen, Hovern, Dragging oder CSS-Animationen erfasst der INP nicht. Bei jeder Interaktion misst der INP die Gesamtzeit von der Nutzereingabe über die Abarbeitung der Event-Handler bis zum nächsten gezeichneten Frame auf dem Bildschirm.
Warum ist mein INP auf Mobilgeräten schlechter?
Smartphones haben langsamere Prozessoren und weniger Arbeitsspeicher als Desktops. Dasselbe JavaScript braucht auf einem Smartphone länger, weshalb der main thread häufiger blockiert ist, wenn der Besucher tippt. CoreDash-Daten zeigen, dass der mobile INP (131 ms beim 75. Perzentil) 2,8-mal schlechter ist als auf dem Desktop (48 ms). Um den mobilen INP zu verbessern, musst du die JavaScript-Ausführungszeit senken, Long Tasks aufbrechen und die DOM-Komplexität minimieren.
Weiterführende Leitfäden
Jede Phase des INP wird in einem eigenen Guide vertieft:
- <strong>INP-Probleme finden und beheben</strong>: vom Search-Console-Bericht bis zur langsamen Interaktion, mit RUM-Daten und DevTools.
- <strong>INP Input Delay</strong>: Long Tasks, die den Klick warten lassen.
- <strong>INP Processing Time</strong>: Event-Handler und was erst nach dem Bildschirm-Update laufen sollte.
- <strong>INP Presentation Delay</strong>: DOM-Größe, Layout Thrashing und Re-Renders.
Passende PageSpeed-Leitfäden:

Brauchst du eine schnellere Website?
Ich bin Arjen und mache seit 17 Jahren langsame Websites schnell. Wenn du auf Probleme stößt, die du nicht selbst lösen kannst, schick mir deine URL und wir reden darüber.
Schick mir deine URL
Warum funktioniert unser Fix nicht?
Manchmal liefert das CDN noch das alte HTML aus, oder der Fix steckt im Desktop-Template und Mobilgeräte nutzen ein anderes. Schick mir deine URL und das Problem, dann antworte ich mit ein paar Terminvorschlägen. Ich prüfe zuerst deine Field Data, dann arbeiten wir eine Stunde an deiner Website, und innerhalb eines Tages hast du meine Notizen schriftlich. 350 € zzgl. MwSt.
Schick mir deine URLKein Entwickler für den Fix? Ich mache die Arbeit selbst, auf einer Kopie deiner Website.