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.

Arjen Karel Core Web Vitals Consultant
Arjen Karel - linkedin
Last update: 2026-10-07

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.

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.

AspektFirst Input Delay (FID)Interaction to Next Paint (INP)
StatusEingestellt (März 2024)Aktiver Core Web Vital
Gemessene InteraktionenNur die erste InteraktionAlle Interaktionen der gesamten Sitzung
Erfasste PhasenNur Input DelayInput Delay + Processing Time + Presentation Delay
Schwellenwert für „Gut“100 ms200 ms
Ermittlung des MesswertsVerzögerung der ersten EingabeLangsamste 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.

Diagram showing Interaction to Next Paint with three phases: Blocking Tasks, Processing Time, Presentation delay

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.

INP performance bar: GOOD ≤200 ms, NEEDS IMPROVEMENT 200–500 ms, POOR >500 ms

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:

  1. 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.
  2. Nutze content-visibility für Lazy Rendering von Off-Screen-Inhalten. Die CSS-Eigenschaft content-visibility: auto beschleunigt 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:

Passende PageSpeed-Leitfäden:

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

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
Arjen Karel
Arjen Karel, Web-Performance-Consultant seit 2009

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 URL

Kein Entwickler für den Fix? Ich mache die Arbeit selbst, auf einer Kopie deiner Website.

Interaction to Next Paint (INP): Was er ist, wie du ihn misst und verbesserst Core Web Vitals Interaction to Next Paint (INP): Was er ist, wie du ihn misst und verbesserst