Core Web Vitals verbessern: LCP, INP und CLS
Veröffentlicht am Aktualisiert am 47 Min Lesezeit Mario Laurich
Eine langsame Website merkt jeder Besucher, lange bevor ein Tool etwas anzeigt. Seit 2021 messen Googles Core Web Vitals genau das, und Google nutzt sie auch in der Suche. Deutsche Websites haben dabei ein paar eigene Baustellen: Lange Komposita sprengen mobile Layouts, Cookie-Banner nach deutschem Recht kosten Rendering-Zeit und verschieben Inhalt, und beim Hosting spielt der Datenschutz mit.
In diesem Artikel geht es um die Theorie hinter den Core Web Vitals und um konkrete Lösungen, die ich für deutsche Websites für sinnvoll halte. Das Ziel sind LCP unter 2,5 Sekunden, INP unter 200 ms und CLS unter 0,1, und zwar so, dass Einwilligung und Datenschutz dabei nicht unter den Tisch fallen. Von der Bildoptimierung über JavaScript-Loading bis zum automatisierten Monitoring.
Was sind Core Web Vitals?
Core Web Vitals sind drei zentrale Metriken, die Google zur Bewertung der Nutzererfahrung einer Website verwendet. Sie messen verschiedene Aspekte der Performance. Seit Juni 2021 nutzt Google sie in der Suche. Gute Werte sind dabei kein Freifahrtschein: Relevanz zählt mehr, und Google sagt selbst, dass gute Core Web Vitals keine Top-Platzierung garantieren (Search Central).
Largest Contentful Paint (LCP)
Was ist LCP überhaupt?
Stell dir vor, du besuchst eine Website und wartest darauf, dass sie lädt. LCP (Largest Contentful Paint) misst genau das: Wie lange dauert es, bis das größte sichtbare Element auf deiner Seite vollständig geladen und dargestellt wird?
Warum ist das wichtig?
LCP ist ein direkter Indikator dafür, wann deine Besucher den Hauptinhalt deiner Seite sehen können. Eine langsame LCP bedeutet, dass Nutzer länger auf einen “leeren” oder unvollständigen Bildschirm starren müssen. Und das führt oft dazu, dass sie deine Website verlassen, bevor sie überhaupt richtig geladen hat.
Was zählt als “größtes Element”?
Der Browser schaut sich alle sichtbaren Elemente an und identifiziert automatisch das größte. Das sind typischerweise:
- Hero-Bilder: Das große Hauptbild oben auf deiner Seite
- Große Textblöcke: Überschriften oder längere Textabschnitte
- Videos oder Banner: Große Medieninhalte
- Background-Images: Große Hintergrundbilder in CSS
Ein praktisches Beispiel:
<!-- Dieses Hero-Bild ist oft das LCP-Element -->
<div class="hero">
<img src="grosses-hero-bild.jpg" alt="Hauptbild" />
<h1>Willkommen auf meiner Website</h1>
</div>So erkennst du dein LCP-Element:
- Öffne die Chrome DevTools (F12)
- Gehe zum “Performance” Tab
- Starte eine Aufzeichnung und lade deine Seite neu
- In der Timeline siehst du einen “LCP” Marker. Klicke darauf
- Das markierte Element ist dein LCP-Element
LCP-Bewertung verstehen:
- 🟢 Gut: ≤ 2,5 Sekunden. Deine Besucher sehen schnell den Hauptinhalt
- 🟡 Verbesserungsbedürftig: 2,5-4,0 Sekunden. Geht so, aber es gibt Raum für Verbesserungen
- 🔴 Schlecht: > 4,0 Sekunden. Viel zu langsam! Besucher springen wahrscheinlich ab
Häufige LCP-Probleme bei deutschen Websites:
- Große, unoptimierte Bilder: Ein 3MB Hero-Bild lädt auf mobilen Verbindungen sehr langsam
- Langsame Server: Deutsche Hosting-Anbieter können unterschiedliche Response-Zeiten haben
- Zu viele externe Ressourcen: Cookie-Banner, Analytics und Social Media Plugins verzögern das Laden
- Nicht-optimierte Schriften: Große Font-Dateien, die erst spät ankommen
Quick-Wins für bessere LCP:
- Komprimiere deine Bilder: Verwende WebP statt JPEG/PNG
- Nutze ein CDN: Inhalte werden von einem Server in der Nähe deiner Besucher geladen
- Optimiere deinen Server: Schnellere Response-Zeiten bedeuten schnellere LCP
- Priorisiere kritische Inhalte: Das LCP-Element sollte als erstes geladen werden
Interaction to Next Paint (INP)
Was ist INP überhaupt?
Stell dir vor: Du klickst auf einen Button auf einer Website und… nichts passiert. Du klickst nochmal. Immer noch nichts. Frustrierend, oder? Genau das misst INP: wie schnell eine Website auf deine Klicks und Eingaben reagiert.
Bis März 2024 stand an dieser Stelle FID, das nur die Verzögerung der ersten Eingabe gemessen hat. Seit dem 12. März 2024 ist INP die Core Web Vital für die Reaktionszeit (web.dev), und FID spielt in keinem Google-Werkzeug mehr eine Rolle.
Was INP meldet:
INP beobachtet alle Klicks, Taps und Tastendrücke eines Besuchs und meldet die langsamste Reaktion (bei sehr vielen Interaktionen ohne die größten Ausreißer, web.dev). Deshalb reicht ein einziger träger Klick, um den Wert zu ruinieren.
Was zählt als “Interaktion”?
- Klicks: Auf Buttons, Links oder andere klickbare Elemente
- Taps: Berührungen auf Touchscreens (Smartphones/Tablets)
- Tastatureingaben: Tippen in Eingabefelder oder Shortcuts
Wichtig: Scrollen und Hovern (Maus über Element bewegen) zählen nicht als Interaktionen für INP!
Ein praktisches Beispiel:
<!-- Dieser Button sollte sofort reagieren -->
<button onclick="handleClick()">Newsletter abonnieren</button>
<script>
function handleClick() {
// Wenn diese Funktion zu lange dauert,
// verschlechtert sich dein INP-Wert
console.log("Button geklickt!");
}
</script>Warum ist das wichtig?
Eine langsame Reaktionszeit führt zu:
- Frustration: Nutzer denken, die Website ist kaputt
- Mehrfachklicks: Nutzer klicken mehrmals, weil nichts passiert
- Absprungrate: Besucher verlassen deine Website
- Schlechte Bewertungen: “Die Seite ist so langsam!”
Was passiert technisch im Hintergrund?
- Du klickst auf einen Button
- Der Browser registriert den Klick
- JavaScript wird ausgeführt (falls vorhanden)
- Die Seite wird aktualisiert (neue Inhalte werden angezeigt)
- INP misst die Zeit von Schritt 1 bis 4
So erkennst du INP-Probleme:
- Öffne die Chrome DevTools (F12)
- Gehe zum “Performance” Tab
- Starte eine Aufzeichnung
- Interagiere mit deiner Seite (klicken, tippen, etc.)
- Stoppe die Aufzeichnung
- Schaue nach langen “Tasks” (über 50ms), das sind deine Problemstellen
INP-Bewertung verstehen:
- 🟢 Gut: ≤ 200 Millisekunden. Fühlt sich sofort und reaktionsschnell an
- 🟡 Verbesserungsbedürftig: 200-500 Millisekunden. Merkbare Verzögerung, aber noch akzeptabel
- 🔴 Schlecht: > 500 Millisekunden. Deutlich spürbare Verzögerung, frustrierend für Nutzer
Häufige INP-Probleme bei deutschen Websites:
- Cookie-Banner mit komplexer Logik: DSGVO-konforme Banner laden oft schwere JavaScript-Libraries
- Social Media Widgets: Facebook, Twitter & Co. blockieren den Browser
- Analytics-Overkill: Zu viele Tracking-Scripts laufen gleichzeitig
- Große JavaScript-Frameworks: Nicht optimierte React/Vue.js Apps
- Bildergalerien: Komplexe Lightboxes und Slider
Quick-Wins für bessere INP:
- Script-Loading optimieren: Lade nur das JavaScript, was wirklich gebraucht wird
- Code aufteilen: Große Funktionen in kleinere Teile zerlegen
- Third-Party Scripts später laden: Analytics & Co. erst nach den wichtigen Inhalten
- Web Workers nutzen: Schwere Berechnungen in den Hintergrund verlagern
- Debouncing verwenden: Verhindert zu häufige Ausführung von Funktionen
Praktisches Beispiel (Vorher/Nachher):
// Schlecht: Blockiert den Browser
function handleSearch(query) {
const results = searchDatabase(query); // Dauert 300ms
displayResults(results);
}// Besser: Aufgeteilt und asynchron
async function handleSearch(query) {
// Nutzer sieht sofort Feedback
showLoadingSpinner();
// Suche in kleineren Häppchen
const results = await searchDatabaseAsync(query);
hideLoadingSpinner();
displayResults(results);
}Cumulative Layout Shift (CLS)
Was ist CLS überhaupt?
Stell dir vor: Du liest gerade einen interessanten Artikel auf deinem Smartphone und willst auf einen Link klicken. Plötzlich springt der ganze Text nach unten, weil ein Bild oder eine Werbung nachgeladen wird, und statt auf den gewünschten Link klickst du versehentlich auf etwas anderes. Frustrierend, oder?
Genau das misst CLS (Cumulative Layout Shift): Wie stark und wie oft sich Inhalte auf deiner Website unerwartet verschieben, während sie lädt.
Warum ist das wichtig?
Layout-Verschiebungen sind nicht nur nervig, sie können richtig problematisch werden:
- Falsche Klicks: Nutzer klicken auf das falsche Element (z.B. “Kaufen” statt “Zurück”)
- Leseerfahrung: Der Text springt weg, während man noch liest
- Vertrauen: Eine “wackelige” Website wirkt unprofessionell
- Conversion: Nutzer brechen ab, wenn die Seite zu unruhig ist
Was zählt als “Layout-Shift”?
Ein Layout-Shift zählt, wenn sich ein sichtbares Element verschiebt, ohne dass der Nutzer kurz vorher geklickt, getippt oder eine Taste gedrückt hat (der Browser gibt dafür 500 ms Kulanz). Hover und Scrollen sind keine solche Eingabe. Animationen über transform zählen nicht, Animationen über top, margin oder height schon.
Typische Layout-Shift-Verursacher:
- Bilder ohne definierte Größe: Laden nach und schieben anderen Inhalt weg
- Werbebanner: Erscheinen spontan und verschieben den Content
- Web Fonts: Fallback-Font hat andere Abmessungen als die geladene Schrift
- Cookie-Banner: Tauchen auf und schieben den Inhalt nach oben
- Dynamische Inhalte: Nachrichten, Kommentare oder Produkte, die nachgeladen werden
Ein praktisches Beispiel:
<!-- SCHLECHT: Keine Bildgröße definiert -->
<div class="article">
<h2>Spannender Artikel</h2>
<p>Hier steht interessanter Text...</p>
<!-- Dieses Bild wird später geladen und schiebt alles nach unten -->
<img src="artikel-bild.jpg" alt="Artikel Bild" />
<p>Mehr Text hier...</p>
</div>
<!-- GUT: Bildgröße ist von Anfang an bekannt -->
<div class="article">
<h2>Spannender Artikel</h2>
<p>Hier steht interessanter Text...</p>
<!-- Browser reserviert sofort Platz für das Bild -->
<img src="artikel-bild.jpg" alt="Artikel Bild" width="800" height="600" />
<p>Mehr Text hier...</p>
</div>So erkennst du CLS-Probleme:
- Visueller Test: Lade deine Seite langsam neu und beobachte, was sich bewegt
- Chrome DevTools: Performance-Panel, Aufzeichnung mit Neuladen, dann die Spur “Layout shifts”. Jede lila Raute ist eine Verschiebung, ein Klick zeigt Element, Score und mögliche Ursache
- Chrome DevTools: Live Metrics zeigen CLS direkt an
CLS-Wert verstehen:
CLS ist keine Zeit-Messung, sondern ein dimensionsloser Wert zwischen 0 und theoretisch unendlich:
- 🟢 Gut: ≤ 0,1. Sehr stabile Seite, kaum merkbare Verschiebungen
- 🟡 Verbesserungsbedürftig: 0,1-0,25. Einige Verschiebungen, sollte optimiert werden
- 🔴 Schlecht: > 0,25. Deutlich störende Sprünge, sehr frustrierend für Nutzer
Wie wird CLS berechnet?
Score einer einzelnen Verschiebung = Impact Fraction × Distance Fraction
Impact Fraction = Welcher Anteil des Bildschirms ist betroffen? Gezählt wird die
Fläche des Elements vorher und nachher zusammen (0 bis 1)
Distance Fraction = Wie weit hat sich das Element bewegt, gemessen an der
größeren Seite des Bildschirms? (0 bis 1)Ein Rechenbeispiel, so steht es auch bei web.dev: Ein Element belegt die Hälfte des Bildschirms und rutscht um ein Viertel der Höhe nach unten. Betroffen ist die Fläche vorher und nachher, also 75 %: 0,75 × 0,25 = 0,1875 (verbesserungsbedürftig).
Der CLS-Wert einer Seite ist nicht dieser eine Score. CLS addiert solche Werte innerhalb eines Zeitfensters (Verschiebungen mit höchstens etwa einer Sekunde Abstand, das Fenster dauert höchstens fünf Sekunden) und nimmt das schlimmste Fenster des Besuchs.
Häufige CLS-Probleme bei deutschen Websites:
- DSGVO-Cookie-Banner: Schieben plötzlich den Inhalt nach oben
- Lange deutsche Wörter: Brechen um und verändern das Layout
- Mehrsprachigkeit: Deutsche Texte sind oft länger als englische
- Web Fonts: Die Fallback-Schrift hat andere Abmessungen als die geladene
- Eingebettete Inhalte: YouTube-Videos, Social Media Posts
- Werbebanner: Besonders Programmatic Advertising
Quick-Wins für bessere CLS:
- Dimensionen definieren: Immer width und height für Bilder und Videos
- CSS aspect-ratio: Moderne Browser unterstützen aspect-ratio: 16/9
- Platz reservieren: Für dynamische Inhalte von Anfang an Platz lassen
- Font Loading:
font-display: optionaloder eine Fallback-Schrift mitsize-adjust, damit der Tausch nichts verschiebt - Fixed Positioning: Cookie-Banner und Popups nicht im Dokumentfluss
Core Web Vitals messen
Bevor du mit der Optimierung beginnst, musst du wissen, wo deine Website steht. Es gibt verschiedene Tools, um die Core Web Vitals zu messen, jedes mit seinen eigenen Vor- und Nachteilen. Hier eine ausführliche Übersicht über die wichtigsten Messmethoden:
Google PageSpeed Insights
Das ist das offizielle kostenlose Tool von Google und meist der erste Anlaufpunkt für eine Performance-Analyse. PageSpeed Insights ist besonders wertvoll, weil es zwei verschiedene Datenquellen kombiniert:
Felddaten (Field Data): Das sind echte Messwerte von echten Nutzern deiner Website über die letzten 28 Tage. Diese Daten stammen aus dem Chrome User Experience Report (CrUX) und zeigen, wie deine Website in der Realität performt (mit unterschiedlichen Verbindungen und Geräten, allerdings nur von Chrome-Nutzern auf Desktop und Android; iPhones fehlen, die Methodik steht in der CrUX-Doku).
Labordaten (Lab Data): Das ist eine simulierte Messung unter kontrollierten Bedingungen. Lighthouse analysiert deine Seite mit einer mittleren Desktop- und Mobilkonfiguration und gibt dir konkrete Verbesserungsvorschläge.
Wie nutzt du PageSpeed Insights richtig?
- Gib deine URL ein und warte auf die Analyse
- Schaue zuerst auf die “Felddaten” (oben), das ist die Realität deiner Nutzer
- Wenn keine Felddaten verfügbar sind (bei neuen Websites), konzentriere dich auf die Labordaten
- Prüfe sowohl Desktop als auch Mobile, denn die Unterschiede können erheblich sein
- Fokussiere dich auf die roten und orangen Bereiche. Das sind deine größten Baustellen
Wichtige Hinweise:
- Felddaten sind nur verfügbar, wenn deine Website genug Traffic hat
- Die Laborwerte können von den echten Nutzererfahrungen abweichen
- Teste verschiedene Seiten deiner Website, nicht nur die Startseite
Chrome DevTools
Die Chrome Developer Tools sind das Schweizer Taschenmesser für Web-Entwickler. Sie bieten deutlich detailliertere Einblicke als PageSpeed Insights und helfen dir dabei, die genauen Ursachen von Performance-Problemen zu finden.
Lighthouse in den DevTools:
Das ist die gleiche Engine, die auch PageSpeed Insights verwendet, nur mit mehr Kontrolle und Details. Du kannst spezifische Bedingungen simulieren (langsame Verbindungen, schwächere Geräte) und bekommst eine Schritt-für-Schritt-Analyse des Ladeprozesses.
So gehst du vor:
- Öffne deine Website in Google Chrome
- Drücke F12 (oder Rechtsklick → “Untersuchen”)
- Wechsle zum “Lighthouse” Tab (manchmal versteckt hinter dem ”>>” Symbol)
- Wähle “Performance” aus (andere Kategorien sind für Core Web Vitals nicht relevant)
- Klicke auf “Analyze page load”
- Warte ca. 30-60 Sekunden auf die Analyse
Performance Panel für Profis:
Das Performance Panel zeigt dir eine Timeline des gesamten Ladeprozesses. Hier siehst du:
- Wann genau das LCP-Element geladen wurde
- Welche JavaScript-Tasks den Browser blockieren (wichtig für INP)
- Wo Layout-Shifts auftreten (CLS-Analyse)
So nutzt du das Performance Panel:
- Öffne den “Performance” Tab (nicht “Lighthouse”)
- Klicke auf den Aufnahme-Button (Kreis-Symbol)
- Lade deine Seite neu (Strg+F5)
- Interagiere mit der Seite (klicken, scrollen, etc.)
- Stoppe die Aufnahme nach ein paar Sekunden
- Analysiere die Timeline: rote Bereiche zeigen Probleme
Network Panel für Bildoptimierung:
Hier siehst du alle geladenen Ressourcen und kannst:
- Übergroße Bilder identifizieren
- Langsame Server-Antworten finden
- Überflüssige Requests entdecken
- Die Ladesequenz optimieren
Live Metrics in Chrome DevTools (ehemals Web Vitals Extension)
Wichtiger Hinweis: Die Web Vitals Extension wurde im Januar 2025 eingestellt. Google hat die Funktionalität komplett in die Chrome DevTools integriert, und dort ist sie sogar noch besser geworden!
Die neuen “Live Metrics” in den Chrome DevTools zeigen dir die Core Web Vitals in Echtzeit an, während du mit deiner Website interagierst. Das ist wie die alte Extension, nur mit mehr Details und direkt im Browser integriert. Wichtig: Live Metrics zeigen deine eigene Sitzung in deinem eigenen Browser. Das ist zum Debuggen gut, aber kein Monitoring der Besucher.
Wie nutzt du Live Metrics?
- Öffne deine Website in Google Chrome
- Drücke F12 für die DevTools
- Gehe zum “Performance” Tab. Die Live Metrics erscheinen beim ersten Öffnen des Panels von selbst, du musst nichts anklicken
- Interagiere mit deiner Seite. Die Werte werden live aktualisiert
Was siehst du in Live Metrics?
- LCP, INP und CLS-Werte in Echtzeit während deiner Interaktion
- Vergleich mit echten Nutzerdaten (CrUX Field Data) für Desktop und Mobile, sobald du die Felddaten im Panel einschaltest
- Detaillierte LCP-Analyse mit Aufschlüsselung nach Phasen
- INP-Interaktionslogs mit genauen Timing-Informationen
Warum ist das besser als die alte Extension?
- Keine separate Extension nötig, alles in einem Tool
- Viel detailliertere Daten und Analysen
- Direkter Zugriff auf Performance-Debugging-Tools
- Vergleich mit echten Nutzerdaten aus dem Chrome User Experience Report
Alternative: Site Speed Extension
Falls du doch eine separate Extension bevorzugst, gibt es die “Site Speed Extension” von DebugBear, die ähnliche Funktionen bietet wie die alte Web Vitals Extension.
Site Speed Extension im Chrome Web Store
Weitere nützliche Tools
WebPageTest: Ein kostenloses Tool, das detaillierte Tests von verschiedenen Standorten weltweit durchführt. Besonders nützlich, um die Performance für deutsche Nutzer zu testen.
GTmetrix: Kombiniert verschiedene Performance-Metriken und bietet übersichtliche Reports mit konkreten Optimierungsvorschlägen.
Real User Monitoring (RUM): Dienste wie Sentry oder New Relic sammeln echte Nutzerdaten und zeigen dir, wie deine Website in der Praxis performt. Google Analytics 4 misst die Core Web Vitals nicht von selbst, dafür braucht es die web-vitals-Bibliothek (Beispiel weiter unten).
Welches Tool solltest du wann verwenden?
- Für den Einstieg: PageSpeed Insights
- Für detaillierte Analyse: Chrome DevTools
- Für kontinuierliches Monitoring: RUM (web-vitals-Bibliothek oder ein RUM-Dienst) und der Core-Web-Vitals-Bericht der Search Console
- Für internationale Tests: WebPageTest
- Für echte Nutzerdaten: RUM-Tools
Wichtiger Hinweis: Verlasse dich nie auf nur ein Tool. Die verschiedenen Messmethoden können unterschiedliche Ergebnisse liefern, weil sie unter verschiedenen Bedingungen messen. Am wichtigsten sind immer die echten Nutzerdaten, die sogenannten “Field Data”.
LCP optimieren: Largest Contentful Paint
Nachdem du jetzt verstehst, was LCP ist und wie es gemessen wird, kommen wir zu den praktischen Optimierungsmöglichkeiten. LCP-Optimierung dreht sich hauptsächlich um drei Bereiche: schnellere Server, optimierte Bilder und clevere CSS-Strategien.
Bilder optimieren
Da Bilder häufig das LCP-Element sind (besonders Hero-Bilder), ist deren Optimierung oft der wichtigste Hebel für bessere LCP-Werte.
Warum sind Bilder so kritisch für LCP?
Stell dir vor: Ein Besucher öffnet deine Website und das erste, was er sehen soll, ist dein beeindruckendes Hero-Bild. Wenn dieses Bild 3MB groß ist und über eine mobile Verbindung lädt, wartet der Nutzer möglicherweise mehrere Sekunden, bis er endlich deine Seite sieht. Das ist viel zu lange!
Die wichtigsten Bildoptimierungen im Detail:
Moderne Bildformate wie WebP und AVIF sind bei vergleichbarer Qualität oft deutlich kleiner als herkömmliche JPEG-Dateien. Das bedeutet weniger Datenübertragung und damit schnellere Ladezeiten. Wie <picture> und <img> mit srcset, loading und fetchpriority zusammenarbeiten, steht in der Referenz unter picture und img.
<!-- Moderne Bildformate verwenden -->
<picture>
<!-- Browser versucht AVIF (neuestes, kleinstes Format) -->
<source srcset="hero.avif" type="image/avif" />
<!-- Falls AVIF nicht unterstützt: WebP (weit verbreitet, klein) -->
<source srcset="hero.webp" type="image/webp" />
<!-- Fallback für alle anderen Browser: JPEG -->
<img src="hero.jpg" alt="Hero Bild" loading="eager" />
</picture>
<!-- Für kritische Bilder: Hohe Priorität -->
<img src="hero.jpg" alt="Hero" loading="eager" fetchpriority="high" />Responsive Images passen sich automatisch an die Bildschirmgröße an. Ein Smartphone braucht keine 4K-Auflösung. Das spart erheblich Datenvolumen:
<!-- Verschiedene Bildgrößen für verschiedene Bildschirme -->
<img
src="hero-800w.jpg"
srcset="
hero-400w.jpg 400w,
hero-800w.jpg 800w,
hero-1200w.jpg 1200w,
hero-1600w.jpg 1600w
"
sizes="(max-width: 600px) 400px,
(max-width: 1200px) 800px,
1200px"
alt="Hero Bild"
loading="eager"
/>Ohne Angabe lädt der Browser Bilder sofort (eager ist laut MDN der Standard), loading="eager" ist hier also nur zur Klarheit gesetzt. Wichtig ist vor allem, dem Hero-Bild kein loading="lazy" zu geben, wie es manche CMS und Bild-Komponenten automatisch tun. Lazy Loading ist für Bilder weiter unten auf der Seite gedacht. fetchpriority="high" schiebt das Hero-Bild zusätzlich nach vorn.
Praktische Bildoptimierung Checkliste:
- WebP und AVIF-Formate erstellen (Tools: ImageOptim, Squoosh.app, oder Build-Tools)
- Responsive Images mit mehreren Auflösungen erstellen
- LCP-Bild nie mit
loading="lazy"laden fetchpriority="high"für das wichtigste Bild setzen- Bildkompression ohne sichtbaren Qualitätsverlust anwenden
- CDN für weltweite Bildauslieferung nutzen
Häufige Fehler vermeiden:
Viele Entwickler laden das Hero-Bild als CSS-Background-Image. Das ist schlecht für LCP, weil der Browser erst das CSS parsen muss, bevor er mit dem Bilddownload beginnt. Nutze stattdessen HTML-<img>-Tags für LCP-kritische Bilder.
Server-Response-Zeit verbessern
Eine schnelle Server-Antwort ist die Grundlage für alle anderen Optimierungen. Gemessen wird sie als TTFB (Time to First Byte). Wenn dein Server 3 Sekunden braucht, um zu antworten, können auch die besten Bilder das nicht ausgleichen. TTFB ist keine Core Web Vital, aber eine Vorstufe von LCP: Was hier verbraucht wird, fehlt später.
Was passiert bei einer Server-Anfrage?
- Der Browser fragt deine Website an
- Der Server verarbeitet die Anfrage (Datenbank-Abfragen, HTML-Generierung, etc.)
- Der Server sendet die Antwort zurück
- Der Browser beginnt mit dem Rendern
Die Zeit von Schritt 1 bis 3 ist der Hauptteil deiner Server-Response-Zeit. TTFB misst allerdings etwas mehr als die reine Serverzeit: Weiterleitungen, DNS-Auflösung sowie Verbindungs- und TLS-Aufbau gehören dazu. web.dev nennt 0,8 Sekunden als guten Wert und alles über 1,8 Sekunden als schlecht. Je weniger davon verbraucht ist, desto mehr Luft bleibt für LCP.
Praktische Server-Optimierungen:
Kompression spart bei Textdateien (HTML, CSS, JavaScript) einen großen Teil der Datenübertragung:
// Node.js/Express: Kompression aktivieren
const compression = require("compression");
// Ab compression 1.8 wählt die Middleware Brotli oder Gzip selbst,
// je nachdem, was der Browser im Accept-Encoding-Header anbietet.
app.use(compression());Brotli kann compression seit Version 1.8.0 (Februar 2025), aktuell ist 1.8.2. Wie app.use() und Middleware allgemein funktionieren, erklärt der Node.js-Kurs in der Lektion Was ist Middleware?.
Caching-Headers sagen dem Browser, wie lange er Dateien lokal speichern soll. Bilder, CSS und JavaScript können meist sehr lange gecacht werden:
// Cache-Headers für statische Ressourcen setzen
app.use((req, res, next) => {
// 1 Jahr cachen, aber nur für Dateien mit Hash im Namen (app.3f9a2c.js),
// wie Vite, Webpack oder Astro sie erzeugen. Der Name ändert sich mit dem
// Inhalt, also kann nichts veralten. Sie liegen hier unter /assets/.
if (req.path.startsWith("/assets/")) {
res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
}
// HTML-Seiten: Kurz cachen oder validieren
else if (req.path.endsWith(".html") || req.path === "/") {
res.setHeader("Cache-Control", "public, max-age=300, must-revalidate");
}
// Dateien ohne Hash (styles.css): kurze Laufzeit oder no-cache mit ETag
next();
});Mit immutable auf einer Datei ohne Hash bekommen Besucher ein geändertes styles.css ein Jahr lang nicht zu sehen. Deshalb steht die Bedingung auf dem Ordner und nicht auf der Dateiendung. Warum req.path und nicht req.url: In req.url hängt der Query-String (style.css?v=2), und der würde eine Endungsprüfung kippen. Mehr zu statischen Dateien in Express gibt es im Node.js-Kurs in der Lektion Statische Dateien.
Content Delivery Network (CDN) nutzen:
Ein CDN speichert Kopien deiner Website auf Servern weltweit. Deutsche Nutzer laden dann von einem Server in Frankfurt statt aus den USA. Das spart bei jedem Verbindungsaufbau Zeit. Beliebte CDNs sind Cloudflare, AWS CloudFront oder KeyCDN.
Datenbankoptimierungen:
Langsame Datenbank-Abfragen sind oft der Grund für schlechte Server-Response-Zeiten:
- Datenbankindizes für häufige Abfragen erstellen
- N+1-Query-Probleme vermeiden
- Query-Caching implementieren
- Verbindungspooling nutzen
Critical CSS
Critical CSS ist der CSS-Code, der für den sichtbaren Bereich (Above-the-Fold) deiner Website benötigt wird. Statt das komplette CSS zu laden und zu parsen, lädst du nur das Nötige inline und den Rest asynchron.
Warum ist das wichtig für LCP?
Normalerweise blockiert CSS das Rendering: der Browser zeigt nichts an, bis alles CSS geladen und verarbeitet wurde. Mit Critical CSS kann der Browser sofort den sichtbaren Bereich rendern, während das restliche CSS im Hintergrund nachlädt.
Praktische Umsetzung:
<!DOCTYPE html>
<html>
<head>
<!-- Critical CSS direkt inline -->
<style>
/* Nur CSS für above-the-fold Inhalt */
body {
font-family: Arial, sans-serif;
margin: 0;
}
.hero {
background: linear-gradient(135deg, #007acc, #0056a3);
color: white;
padding: 60px 20px;
text-align: center;
min-height: 400px;
display: flex;
align-items: center;
justify-content: center;
}
.hero h1 {
font-size: 3rem;
margin: 0;
font-weight: 700;
}
</style>
<!-- Restliches CSS asynchron laden -->
<link
rel="preload"
href="styles.css"
as="style"
onload="this.onload=null;this.rel='stylesheet'"
/>
<!-- Fallback für Browser ohne JavaScript -->
<noscript><link rel="stylesheet" href="styles.css" /></noscript>
</head>
<body>
<!-- Der Hero-Bereich wird sofort gerendert -->
<div class="hero">
<h1>Willkommen auf meiner Website</h1>
</div>
<!-- Weiterer Content hier... -->
</body>
</html>Tools zur Critical CSS-Extraktion:
- Online-Tools: Critical Path CSS Generator, Sitelocity
- Build-Tools: critical, Penthouse, Beasties (der Nachfolger von Critters). Ungenutztes CSS entfernen dagegen PurgeCSS und UnCSS, das ist ein anderes Problem
- CMS-Plugins: WordPress Critical CSS Plugins
Was gehört ins Critical CSS?
- Header und Navigation
- Hero-Bereich
- Alles, was ohne Scrollen sichtbar ist
- Grundlegende Typography und Layout-Styles
- Basis-Responsive-Breakpoints
Was NICHT ins Critical CSS gehört:
- Footer-Styles
- Formularstyling für Bereiche weiter unten
- Komplexe Animationen
- Print-Styles
- Hover-Effekte für Desktop
Häufige Fehler beim Critical CSS:
Zu viel Critical CSS macht die HTML-Datei groß und verlangsamt den initialen Download. Die Faustregel: Das HTML samt Critical CSS sollte komprimiert unter etwa 14 KB bleiben. So viel darf der Server laut web.dev in der ersten Runde schicken, bevor er auf eine Bestätigung des Browsers warten muss. Die 14 KB sind also nicht die Größe eines einzelnen TCP-Pakets (die liegt deutlich darunter), sondern die Menge, die in der ersten Runde über die Leitung darf.
Advanced: Frameworks
Bei modernen Frameworks nimmt dir der Build das Extrahieren ab. Next.js kann das CSS über die experimentelle Option inlineCss in <head> setzen. Das inlinet allerdings das gesamte CSS und nicht nur das kritische, die Doku empfiehlt es für kleines CSS wie bei Tailwind. In Astro- und Vite-Projekten kannst du das Paket critical im Build laufen lassen.
Messen des Erfolgs:
Nach der Critical CSS-Implementation solltest du deutliche Verbesserungen sehen:
- First Contentful Paint (FCP) wird schneller
- Largest Contentful Paint (LCP) verbessert sich
- PageSpeed Insights zeigt bessere Scores
- Nutzer sehen Inhalte früher
Critical CSS kann LCP verbessern, weil es das Rendering-Blocking reduziert und den sichtbaren Inhalt priorisiert. Wie viel es bringt, hängt davon ab, wie groß dein CSS ist und wie oft deine Besucher zurückkommen: Inline-CSS umgeht den Browser-Cache, deshalb gehört es sparsam eingesetzt.
INP optimieren: Interaktivität verbessern
Nachdem du verstanden hast, was INP misst, kommen wir zu den praktischen Optimierungsmöglichkeiten. Die Interaktivität deiner Website hängt hauptsächlich davon ab, wie schnell der Browser auf Nutzereingaben reagieren kann, und das wird meist durch JavaScript blockiert.
Was passiert technisch bei einer Interaktion?
Stell dir vor, ein Nutzer klickt auf einen Button auf deiner Website. Folgendes passiert im Browser:
- Event wird registriert: Der Browser erkennt den Klick
- JavaScript wird ausgeführt: Alle Event-Handler und damit verbundener Code läuft
- DOM wird aktualisiert: Änderungen am HTML werden vorgenommen
- Rendering: Der Browser zeichnet die Änderungen auf dem Bildschirm
- Paint: Der Nutzer sieht das Ergebnis seiner Aktion
INP misst die Zeit von Schritt 1 bis 5. Wenn einer dieser Schritte zu lange dauert, verschlechtert sich dein INP-Wert und die Website fühlt sich träge an.
Die Hauptursachen für schlechte INP-Werte:
JavaScript ist single-threaded. Das bedeutet, der Browser kann jeweils nur eine JavaScript-Aufgabe zur Zeit ausführen. Wenn eine Aufgabe lange dauert, blockiert sie alle anderen Aufgaben, inklusive Nutzerinteraktionen. Das nennt man “Main Thread Blocking”.
Typische “Thread-Blocker” sind:
- Komplexe Berechnungen
- Große Datenmengen verarbeiten
- Schwere Third-Party Scripts
- Ineffiziente DOM-Manipulationen
- Synchrone API-Aufrufe
JavaScript optimieren
Das Grundproblem verstehen:
JavaScript blockiert den Main Thread und verschlechtert die Interaktivität. Hier ein einfaches Beispiel für problematischen Code:
// SCHLECHT: Blockiert den Browser für mehrere Sekunden
function processAllDataAtOnce(data) {
const results = [];
// Diese Schleife kann bei 10.000+ Elementen mehrere Sekunden dauern
for (let i = 0; i < data.length; i++) {
// Komplexe Berechnung pro Element
const result = performComplexCalculation(data[i]);
results.push(result);
}
return results;
}
// Nutzerklicks werden ignoriert, während diese Funktion läuft!
button.addEventListener("click", () => {
const data = getHugeDataset(); // 10.000+ Elemente
processAllDataAtOnce(data); // Browser friert ein
});Die Lösung: Task Splitting (Aufgaben aufteilen)
Statt alles auf einmal zu verarbeiten, teilst du große Aufgaben in kleinere Häppchen auf und gibst dem Browser regelmäßig die Kontrolle zurück:
// Gibt den Main Thread frei. Wo der Browser es kann, mit scheduler.yield(),
// sonst mit setTimeout.
function yieldToMain() {
if (globalThis.scheduler?.yield) {
return scheduler.yield();
}
return new Promise((resolve) => setTimeout(resolve, 0));
}
// BESSER: Aufgabe in kleine Teile aufteilen
async function processLargeDataset(data) {
const results = [];
const batchSize = 100; // Nur 100 Elemente pro Batch
for (let i = 0; i < data.length; i += batchSize) {
const batch = data.slice(i, i + batchSize);
// Batch verarbeiten
for (const item of batch) {
const result = performComplexCalculation(item);
results.push(result);
}
// WICHTIG: Main Thread freigeben
// Browser kann jetzt auf Nutzerklicks reagieren
await yieldToMain();
// Optional: Progress anzeigen
updateProgressBar((i + batchSize) / data.length);
}
return results;
}
// Jetzt bleibt die UI reaktionsschnell
button.addEventListener("click", async () => {
showLoadingSpinner();
const data = getHugeDataset();
const results = await processLargeDataset(data);
hideLoadingSpinner();
displayResults(results);
});Warum funktioniert das?
yieldToMain() gibt die Kontrolle an den Browser zurück. Der Browser kann dann:
- Auf Nutzerinteraktionen reagieren
- Das Layout neu berechnen
- Den Bildschirm aktualisieren
- Andere wichtige Aufgaben erledigen
Wo der Browser es kann (Chrome und Edge ab Version 129, Firefox ab 142), nehme ich scheduler.yield(). Die Fortsetzung läuft danach vorrangig weiter und wird nicht von anderen wartenden Aufgaben überholt. Mit setTimeout reiht sie sich dagegen hinten ein. Safari kennt scheduler.yield() nicht, dort greift der setTimeout-Fallback. Das steht auch in Optimize long tasks auf web.dev. Falls dir bei async und await noch etwas wackelt: Im JavaScript-Kurs gibt es dazu die Lektionen Promises und async und await.
Advanced: Web Workers für schwere Berechnungen
Für wirklich schwere Berechnungen kannst du Web Workers verwenden. Das sind separate Threads, die den Main Thread gar nicht blockieren:
// worker.js - Läuft in separatem Thread
self.addEventListener("message", function (e) {
const data = e.data;
// Schwere Berechnung hier - blockiert NICHT die UI
const results = performComplexCalculation(data);
// Ergebnis zurücksenden
self.postMessage(results);
});
// main.js - Hauptthread bleibt frei
button.addEventListener("click", () => {
const worker = new Worker("worker.js");
worker.postMessage(largeDataset);
worker.addEventListener("message", (e) => {
const results = e.data;
displayResults(results);
worker.terminate(); // Worker beenden
});
// Button reagiert sofort, auch während der Berechnung
updateButtonText("Berechnung läuft...");
});Falls du mehr über Web Worker lernen möchtest, dazu habe ich ein ausführliches YouTube-Tutorial erstellt.
Praktische Optimierungstipps für JavaScript:
Timer und Intervals optimieren:
// Schlecht: setInterval kennt weder den Bildschirmtakt noch die Sichtbarkeit
setInterval(updateAnimation, 16); // 60fps
// Besser: requestAnimationFrame läuft im Takt des Bildschirms,
// und der Browser pausiert es im Hintergrund-Tab von selbst
function animate() {
updateAnimation();
requestAnimationFrame(animate);
}
requestAnimationFrame(animate);Event-Handler optimieren:
// Schlecht: Event-Handler auf jedem Element
document.querySelectorAll(".button").forEach((btn) => {
btn.addEventListener("click", handleClick);
});
// Besser: Event Delegation
document.addEventListener("click", (e) => {
// closest(), weil e.target auch ein Icon oder <span> im Button sein kann
const btn = e.target.closest(".button");
if (btn) {
handleClick(e);
}
});Wie das mit Bubbling zusammenhängt, steht im JavaScript-Kurs in der Lektion Event-Delegation.
Third-Party Scripts
Das Problem mit externen Scripts:
Third-Party Scripts (Google Analytics, Cookie-Banner, Social Media Widgets, etc.) sind oft die größten Performance-Killer. Sie können:
- Den Main Thread blockieren
- Lange Netzwerk-Requests verursachen
- Andere Scripts beim Laden behindern
- Unvorhersehbar viel JavaScript ausführen
Besonders problematisch bei deutschen Websites:
Cookie-Banner von der Stange laden oft schwere JavaScript-Bibliotheken. Wie schwer, hängt vom Anbieter ab. Was dein Banner mitbringt, siehst du im Network-Reiter der DevTools.
<!-- Typischer Cookie-Banner - lädt sofort beim Seitenaufruf -->
<script src="https://cookie-banner.com/sdk.js"></script>
<script>
CookieBanner.init({
// Komplexe Konfiguration mit vielen Optionen
gdprCompliant: true,
languages: ['de', 'en', 'fr'],
analytics: true,
advertising: true,
// ... und viele weitere Optionen
});
</script>Die Lösung: Third-Party Scripts gezielt laden
Lade externe Scripts erst, wenn sie wirklich benötigt werden. Was eine Einwilligung braucht, lädt erst nach der Zustimmung, nie vorher und auch nicht “verzögert”: Eine Verzögerung ändert nichts daran, dass es ohne Einwilligung geladen würde. Erst wenn jemand zugestimmt hat, lohnt es sich, den Start hinter das Rendern zu schieben:
<!-- Third-Party Scripts intelligent laden -->
<script>
// Analytics und Marketing laden erst nach der Einwilligung,
// nie vorher, auch nicht verzögert.
function loadAnalytics() {
const script = document.createElement("script");
script.src = "https://www.googletagmanager.com/gtag/js?id=GA_ID";
script.async = true;
document.head.appendChild(script);
// Analytics initialisieren
window.dataLayer = window.dataLayer || [];
window.gtag = function () {
dataLayer.push(arguments);
};
gtag("js", new Date());
gtag("config", "GA_ID");
}
// Wer schon zugestimmt hat: erst nach dem Rendern laden
if (localStorage.getItem("cookie-consent") === "accepted") {
window.addEventListener("load", () => {
setTimeout(loadAnalytics, 2000); // gibt der Seite Zeit zum Rendern
});
}
// Wer noch nicht entschieden hat, sieht den Banner. Er erscheint sofort
// und liegt fixed über dem Inhalt (siehe Abschnitt zu CLS).
</script>Noch besser: User Interaction basiertes Laden
Lade Scripts erst, wenn der Nutzer tatsächlich interagiert:
// Social Media Widgets erst bei Bedarf laden (und wie Analytics erst nach der
// Einwilligung, denn auch das Widget schickt Daten an den Anbieter)
function loadSocialMediaWidget() {
if (window.socialMediaLoaded) return;
if (localStorage.getItem("cookie-consent") !== "accepted") return;
const script = document.createElement("script");
script.src = "https://platform.twitter.com/widgets.js";
script.async = true;
document.head.appendChild(script);
window.socialMediaLoaded = true;
}
// Laden wenn Nutzer in den Bereich scrollt
const socialSection = document.querySelector(".social-media-section");
const observer = new IntersectionObserver((entries) => {
entries.forEach((entry) => {
if (entry.isIntersecting) {
loadSocialMediaWidget();
observer.unobserve(entry.target);
}
});
});
observer.observe(socialSection);Resource Hints für bessere Performance:
Mit Resource Hints kannst du den Browser auf Verbindungen vorbereiten, die die Seite ohnehin braucht (mehr zu <link> steht in der Referenz unter link):
<!-- DNS-Lookup vorab durchführen -->
<link rel="dns-prefetch" href="//widgets.example.com" />
<!-- Verbindung vorab aufbauen, z. B. zu einem eigenen Bild-CDN -->
<link rel="preconnect" href="https://cdn.example.com" crossorigin />Eine Einschränkung, die ich bei Hints zu Drittanbietern beachte: Schon der Verbindungsaufbau geht an deren Server. Bei Anbietern, deren Skripte erst nach einer Einwilligung laden dürfen, setze ich deshalb auch keine Hints vorab. Das gilt auch für Google Fonts: Die Schriften hoste ich selbst (mehr dazu beim Cookie-Banner).
Code Splitting
Was ist Code Splitting?
Statt dein komplettes JavaScript auf einmal zu laden, teilst du es in kleine Stücke auf. Jeder Bereich deiner Website lädt nur das JavaScript, das er wirklich braucht.
Warum ist das wichtig?
Ein typisches Beispiel: Deine Website hat eine Kontaktform, ein Bildergalerie-Modal und eine Suchfunktion. Warum soll ein Nutzer, der nur einen Blogartikel lesen will, das JavaScript für alle diese Features laden?
// SCHLECHT: Alles wird immer geladen
import { ContactForm } from "./contact-form.js"; // 50KB
import { ImageGallery } from "./image-gallery.js"; // 80KB
import { SearchFunction } from "./search.js"; // 30KB
import { BlogReader } from "./blog-reader.js"; // 20KB
// Insgesamt: 180KB JavaScript - auch für einfache Blogbesucher!Die Lösung: Dynamic Imports
Lade JavaScript-Module erst, wenn sie gebraucht werden:
// Modal nur laden wenn tatsächlich geöffnet wird
const loadModal = async () => {
// Dieser Code wird erst ausgeführt, wenn die Funktion aufgerufen wird
const { ImageGallery } = await import("./image-gallery.js");
return new ImageGallery();
};
// Event-Handler
document.querySelectorAll(".gallery-trigger").forEach((button) => {
button.addEventListener("click", async (e) => {
e.preventDefault();
// Zeige Loading-Indikator
button.textContent = "Laden...";
button.disabled = true;
try {
// Modal-Code laden und initialisieren
const gallery = await loadModal();
gallery.open(button.dataset.galleryId);
} catch (error) {
console.error("Fehler beim Laden der Galerie:", error);
} finally {
// Loading-Zustand zurücksetzen
button.textContent = "Galerie öffnen";
button.disabled = false;
}
});
});Route-basiertes Code Splitting:
Besonders bei Single-Page-Applications (SPAs) ist das sehr effektiv:
// Router mit Code Splitting
const router = {
"/": () => import("./pages/home.js"),
"/blog": () => import("./pages/blog.js"),
"/contact": () => import("./pages/contact.js"),
"/admin": () => import("./pages/admin.js"), // Nur für Admins
};
async function navigateTo(path) {
// Aktuelle Seite bereinigen
const app = document.querySelector("#app");
app.innerHTML = '<div class="loading">Seite wird geladen...</div>';
try {
// Nur das JavaScript für die aktuelle Seite laden
const pageModule = await router[path]();
const page = new pageModule.default();
// Seite rendern
app.innerHTML = "";
page.render(app);
} catch (error) {
app.innerHTML = '<div class="error">Fehler beim Laden der Seite</div>';
}
}Feature-basiertes Code Splitting:
Lade Features erst, wenn sie benötigt werden:
// Kommentar-System nur laden wenn Nutzer kommentieren will
async function loadCommentSystem() {
if (window.commentSystemLoaded) return;
const [{ CommentForm }, { CommentList }, { CommentValidation }] =
await Promise.all([
import("./comment-form.js"),
import("./comment-list.js"),
import("./comment-validation.js"),
]);
// Kommentar-System initialisieren
const commentSystem = new CommentSystem({
form: CommentForm,
list: CommentList,
validation: CommentValidation,
});
commentSystem.init();
window.commentSystemLoaded = true;
}
// Erst laden wenn "Kommentieren" Button geklickt wird
document.querySelector(".comment-trigger")?.addEventListener("click", () => {
loadCommentSystem();
});Build-Tool Integration:
Moderne Build-Tools unterstützen automatisches Code Splitting:
// Webpack erkennt automatisch Dynamic Imports
const button = document.querySelector(".advanced-feature");
button.addEventListener("click", async () => {
// Webpack erstellt automatisch einen separaten Bundle für dieses Module
const { AdvancedFeature } = await import("./advanced-feature.js");
const feature = new AdvancedFeature();
feature.initialize();
});Messen des Erfolgs:
Nach dem Implementieren von Code Splitting solltest du sehen:
- Kleinere initiale Bundle-Größe
- Schnellerer First Paint
- Bessere INP-Werte
- Reduzierter JavaScript-Parse-Time
Code Splitting ist besonders effektiv in Kombination mit anderen Optimierungen und kann deine INP-Werte erheblich verbessern, da weniger JavaScript-Code initial geparst und ausgeführt werden muss.
CLS optimieren: Layout-Stabilität
Layout-Shifts sind wie unerwartete Sprünge im Design deiner Website. Sie passieren meist genau dann, wenn ein Nutzer etwas anklicken möchte. Das ist nicht nur frustrierend, sondern kann auch teuer werden: Stell dir vor, ein Nutzer will auf “Zurück” klicken, aber plötzlich springt ein “Jetzt kaufen” Button an diese Stelle. Solche Unfälle kosten Vertrauen und Conversions.
Die gute Nachricht: CLS-Probleme lassen sich systematisch vermeiden, indem du dem Browser von Anfang an mitteilst, wie viel Platz verschiedene Elemente brauchen. Hier die wichtigsten Strategien im Detail:
Bildgrößen definieren
Das häufigste CLS-Problem sind Bilder ohne definierte Größe. Der Browser lädt das HTML, zeigt den Text an, und sobald das Bild nachlädt, springt der gesamte Inhalt nach unten. Für den Nutzer sieht das so aus, als würde die Seite “zusammenbrechen”.
Das Problem verstehen:
Ohne Größenangaben kann der Browser nicht wissen, wie viel Platz er für ein Bild reservieren soll. Er zeigt also zunächst gar keinen Platz an (das Bild hat eine Höhe von 0 Pixeln). Sobald das Bild lädt und seine echte Größe bekannt wird, muss der Browser alles andere nach unten schieben, um Platz zu schaffen.
Die Lösung: Dimensionen von Anfang an mitteilen
<!-- SCHLECHT: Keine Größenangaben -->
<div class="article">
<h2>Interessanter Artikel</h2>
<p>Hier steht spannender Text, den der Nutzer gerade liest...</p>
<!-- Dieses Bild wird später geladen und schiebt alles nach unten -->
<img src="article-image.jpg" alt="Artikel Bild" />
<p>Dieser Text springt nach unten, sobald das Bild lädt!</p>
</div>
<!-- GUT: Explizite Dimensionen -->
<div class="article">
<h2>Interessanter Artikel</h2>
<p>Hier steht spannender Text, den der Nutzer gerade liest...</p>
<!-- Browser weiß sofort: 800x600 Pixel reservieren -->
<img src="article-image.jpg" alt="Artikel Bild" width="800" height="600" />
<p>Dieser Text bleibt an seinem Platz!</p>
</div>Moderne Alternative: CSS Aspect Ratio
Falls du die exakten Pixelmaße nicht kennst oder responsive Bilder verwendest, kannst du mit CSS das Seitenverhältnis definieren (mehr dazu in der Referenz unter aspect-ratio):
.image-container {
aspect-ratio: 16 / 9; /* Seitenverhältnis 16:9 */
overflow: hidden; /* Bild bei Bedarf beschneiden */
background-color: #f0f0f0; /* Placeholder-Farbe während des Ladens */
}
.image-container img {
width: 100%;
height: 100%;
object-fit: cover; /* Bild proportional einpassen */
}<div class="image-container">
<img src="responsive-image.jpg" alt="Responsives Bild" loading="lazy" />
</div>Für Videos ist es genauso wichtig:
<!-- YouTube-Videos, Vimeo etc. -->
<div style="aspect-ratio: 16/9; background-color: #000;">
<iframe
width="100%"
height="100%"
src="https://www.youtube-nocookie.com/embed/VIDEO_ID"
title="Beschreibung des Videos"
loading="lazy"
></iframe>
</div>Eine YouTube-Einbettung schickt schon beim Laden der Seite Daten an YouTube, nicht erst beim Klick auf Play. Eine Zwei-Klick-Lösung (Vorschaubild, Video erst nach dem Klick) vermeidet das. Die Domain youtube-nocookie.com allein reicht nach meinem Verständnis nicht, ich würde sie höchstens zusätzlich nehmen. Der title am Iframe ist für Screenreader, und frameborder ist veraltet.
Praktische Tipps für Bilddimensionen:
- Verwende immer
widthundheightAttribute für<img>-Tags - Bei responsiven Bildern nutze CSS
aspect-ratio - Zeige Placeholder-Hintergründe während des Ladens
- Teste verschiedene Bildgrößen mit langsamer Internetverbindung
Font Loading optimieren
Web Fonts sind eine häufige, aber oft übersehene Ursache für Layout-Shifts. Das Problem: Die Textgröße ändert sich plötzlich, wenn die benutzerdefinierte Schrift nachlädt und andere Abmessungen hat als die Fallback-Schrift. Mehr zu @font-face und seinen Deskriptoren steht in der Referenz unter font-face.
Was passiert beim Font-Loading?
- Browser lädt HTML und CSS
- Browser zeigt Text mit Fallback-Font an (z.B. Arial)
- Benutzerdefinierte Schrift lädt im Hintergrund
- Browser wechselt von Arial zu deiner Custom-Font
- Text hat plötzlich andere Abmessungen → Layout-Shift
Die Lösung: font-display richtig konfigurieren
@font-face {
font-family: "MeineCustomFont";
src: url("font.woff2") format("woff2");
font-display: swap; /* Fallback-Font sofort, Tausch später (kann einen Layout-Shift auslösen) */
font-weight: 400;
font-style: normal;
}
/* Fallback-Font möglichst ähnlich wählen */
body {
font-family: "MeineCustomFont", "Arial", sans-serif;
/* Arial hat ähnliche Abmessungen wie viele Custom Fonts */
}Die verschiedenen font-display Optionen verstehen:
swap: Zeigt sofort die Fallback-Schrift und tauscht später aus. Gut für die Lesbarkeit, kann aber einen Layout-Shift auslösenfallback: Wartet etwa 100 ms, zeigt dann die Fallback-Schrift und tauscht nur, wenn die eigene Schrift innerhalb von rund 3 Sekunden kommtoptional: Wartet höchstens 100 ms. Ist die Schrift dann nicht da, bleibt es auf dieser Seite bei der Fallback-Schrift, getauscht wird nie. Beim nächsten Aufruf kommt die Schrift meist aus dem Cacheblock: Wartet auf Custom Font (kann zu unsichtbarem Text führen)
Gegen Layout-Shifts helfen laut web.dev optional (dafür kann es passieren, dass deine Schrift beim ersten Besuch gar nicht erscheint) oder ein Fallback, dessen Maße zur eigenen Schrift passen. Das geht über size-adjust und Verwandte, siehe gleich.
Advanced: Font-Metrics angleichen
Für kritische Projekte kannst du die Fallback-Font-Metriken an deine Custom Font anpassen. Die Werte unten sind nur Beispiele, für deine Schrift musst du sie ausmessen oder ausrechnen:
@font-face {
font-family: "AdjustedArial";
src: local("Arial");
ascent-override: 105%; /* Passt die Schrift-Höhe an */
descent-override: 20%;
line-gap-override: 10%;
size-adjust: 95%; /* Passt die Breite an */
}
body {
font-family: "MeineCustomFont", "AdjustedArial", "Arial", sans-serif;
}Preloading für wichtige Fonts:
<!-- Kritische Fonts vorab laden -->
<link
rel="preload"
href="critical-font.woff2"
as="font"
type="font/woff2"
crossorigin
/>Cookie-Banner und DSGVO
Sobald eine Seite Tracking, Werbung oder andere nicht notwendige Cookies einsetzt, braucht sie eine Einwilligung (§ 25 TDDDG) und damit meist einen Banner. Der wird dann oft zum größten CLS-Verursacher: Er erscheint plötzlich und schiebt den gesamten Inhalt nach oben. Hier sind zwei Lösungsansätze:
Das Problem verstehen:
Die meisten Cookie-Banner werden nachträglich in die Seite eingefügt. Sie sind nicht von Anfang an im HTML vorhanden. Wenn sie erscheinen, haben sie keine reservierte Fläche und verdrängen bestehenden Content.
Lösung 1: Fixed Positioning (Empfohlen)
Der Banner schwebt über dem Inhalt, anstatt ihn zu verschieben:
.cookie-banner {
position: fixed;
bottom: 0;
left: 0;
right: 0;
z-index: 1000;
background: white;
border-top: 1px solid #ccc;
padding: 20px;
box-shadow: 0 -2px 10px rgba(0, 0, 0, 0.1);
/* Ausblenden bis benötigt */
transform: translateY(100%);
transition: transform 0.3s ease-in-out;
}
.cookie-banner.show {
transform: translateY(0);
}
/* Optional: Platz am Bottom für bessere UX */
body.cookie-banner-visible {
padding-bottom: 100px; /* Höhe des Banners */
}Lösung 2: Reservierter Platz (Alternative)
Falls der Banner im Dokumentfluss stehen soll, muss seine Höhe schon im ersten Rendering feststehen. Ein Platzhalter, der erst später von 0 auf 100 px wächst, schiebt alles darunter weg. Das wäre derselbe Layout-Shift wie vorher, nur animiert:
/* Die Höhe steht von Anfang an im Layout, also verschiebt sich nichts */
.cookie-banner-placeholder {
height: 100px; /* tatsächliche Banner-Höhe */
background-color: #f8f9fa;
}
.cookie-banner {
background: white;
padding: 20px;
border-top: 1px solid #ddd;
display: flex;
justify-content: space-between;
align-items: center;
min-height: 100px; /* Konsistente Höhe */
}Beim Schließen kannst du den Platz stehen lassen oder direkt nach dem Klick zusammenklappen. Verschiebungen bis 500 ms nach einem Klick zählen laut web.dev nicht als Layout-Shift.
JavaScript-Implementation:
// Der Banner liegt fixed über dem Inhalt und fährt per transform ein.
// Das verschiebt nichts, deshalb muss er auch nicht auf load warten.
class CookieBannerManager {
constructor() {
this.bannerShown = false;
if (!localStorage.getItem("cookie-consent")) {
this.showBanner();
}
}
showBanner() {
if (this.bannerShown) return;
const banner = document.querySelector(".cookie-banner");
banner.classList.add("show");
document.body.classList.add("cookie-banner-visible");
this.bannerShown = true;
}
// "Alle akzeptieren" und "Ablehnen" rufen dieselbe Methode auf
decide(wert) {
localStorage.setItem("cookie-consent", wert);
this.hideBanner();
// Analytics erst jetzt und nur bei Zustimmung (loadAnalytics steht unten)
if (wert === "accepted") loadAnalytics();
}
hideBanner() {
document.querySelector(".cookie-banner").classList.remove("show");
document.body.classList.remove("cookie-banner-visible");
}
}
// Initialisieren
const cookieBanner = new CookieBannerManager();Im Markup stehen beide Buttons nebeneinander, gleich groß und gleich gestaltet: <button onclick="cookieBanner.decide('accepted')">Alle akzeptieren</button> und <button onclick="cookieBanner.decide('declined')">Ablehnen</button>. Wie loadAnalytics() aussieht, steht im Abschnitt “Einwilligung und Performance” weiter unten.
Einwilligung und Performance, kurz:
- Ich halte Banner-Skripte aus dem kritischen Pfad (
asyncoderdefer) und den Platz für den Banner schon im HTML frei - Schriften selbst hosten statt von Google Fonts laden, auf der ganzen Seite und nicht nur im Banner: Das dynamische Einbinden von Google Fonts hat das LG München I im Urteil vom 20. Januar 2022 (Az. 3 O 17493/20) beanstandet, weil dabei die IP-Adresse ohne Einwilligung an Google geht
- Minimiere die Banner-Höhe durch kompaktes Design
- Biete “Alle akzeptieren” und “Ablehnen” gleichwertig auf der ersten Ebene an. Das fordert die Orientierungshilfe der Datenschutzkonferenz, und für die Performance ist es egal
Testing-Tipp:
Teste deinen Cookie-Banner immer im Inkognito-Modus oder lösche regelmäßig den Local Storage, um das echte Nutzererlebnis zu erleben. Viele Entwickler sehen den Banner nach der ersten Entwicklung nie wieder!
Häufige Fehler vermeiden:
- Banner nicht nachträglich in den DOM einfügen ohne Platzreservierung
- Keine JavaScript-abhängigen Banner-Größen (falls JS nicht lädt)
- Banner-Höhe nicht responsive gestalten
- Third-Party Cookie-Solutions ohne CLS-Optimierung verwenden
Diese Optimierungen sind besonders wichtig für Websites, die Tracking einsetzen und deshalb einen Banner brauchen, etwa viele Shops. Der Banner soll da sein, aber die Conversion-Rate nicht negativ beeinflussen.
Besonderheiten für deutsche Websites
Deutsche Websites haben spezielle Herausforderungen, die internationale Performance-Guides oft nicht berücksichtigen. Die deutsche Sprache, rechtliche Anforderungen und lokale Nutzergewohnheiten stellen besondere Anforderungen an die Performance-Optimierung. Hier eine ausführliche Erklärung der wichtigsten Punkte:
Deutsche Typografie
Warum deutsche Texte besondere Herausforderungen darstellen:
Deutsche Texte unterscheiden sich in mehreren wichtigen Punkten von englischen Texten, was direkte Auswirkungen auf die Website-Performance hat:
Lange Wörter sind im Deutschen normal und können das Layout sprengen. Während “performance optimization” auf Englisch gut in eine Zeile passt, heißt es auf Deutsch “Performance-Optimierung” oder noch länger “Geschwindigkeitsoptimierung”. Diese Wörter können auf mobilen Geräten zu Problemen führen.
Umlaute und ß (ä, ö, ü, ß) kann praktisch jede Webschrift, die Latin-1 abdeckt. Aufpassen musst du nur bei Schriften, die jemand auf englische Zeichen zurechtgeschnitten hat: Fehlen die Umlaute dort, springt der Browser für genau diese Zeichen auf eine andere Schrift.
Deutsche Sätze sind häufig länger und verschachtelter als englische. Das bedeutet mehr Text pro Seite, was die Ladezeiten beeinflusst und mehr Platz für Layout-Probleme schafft.
Praktische Lösungen für deutsche Typografie:
/* Spezielle Behandlung für lange deutsche Wörter */
.text-content {
/* Automatische Silbentrennung, braucht ein lang-Attribut, meist lang="de" am <html> */
hyphens: auto;
/* Wortumbruch für sehr lange Wörter erzwingen */
word-wrap: break-word;
overflow-wrap: break-word;
/* Verhindert horizontales Scrollen auf mobilen Geräten */
max-width: 100%;
}
/* Responsive Typography, die deutsche Textlängen berücksichtigt */
.headline {
/* Schriftgröße passt sich automatisch an Bildschirmgröße an */
font-size: clamp(1.2rem, 3vw, 2.5rem);
/* Mehr Zeilenhöhe für bessere Lesbarkeit bei längeren Wörtern */
line-height: 1.4;
}
/* Container für deutsche Texte */
.german-text-container {
/* Mehr horizontaler Platz für längere Wörter */
max-width: 70ch; /* um die 70 Zeichen pro Zeile sind eine gängige Faustregel für Lesetext */
/* Mehr Padding für bessere Lesbarkeit */
padding: 1.5rem;
}Wie hyphens und overflow-wrap zusammenspielen, steht in der Referenz unter word-break.
Schriftarten für deutsche Texte:
/* Font mit vollständiger deutscher Zeichen-Unterstützung */
@font-face {
font-family: "DeutscheSchrift";
src: url("deutsche-font.woff2") format("woff2");
/* Zeichenbereich: U+0000-00FF deckt Latin-1 ab, also auch ä, ö, ü und ß */
unicode-range:
U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC,
U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF,
U+FFFD;
/* Fallback sofort, Tausch später (kann einen Layout-Shift auslösen, siehe oben) */
font-display: swap;
}
/* Fallback-Font-Stack für deutsche Texte */
.german-text {
font-family:
"DeutscheSchrift", /* deine Custom Font */
system-ui, /* die Systemschrift des Geräts */
Arial, /* universeller Fallback */
sans-serif;
}Warum ist das für Performance wichtig?
Fehlen in einer Schrift die Umlaute, nimmt der Browser genau diese Zeichen aus einer anderen Schrift. Die Zeile wird dadurch anders breit, und das kann einen Layout-Shift auslösen. Das passiert vor allem bei Schriften, die jemand auf englische Zeichen zurechtgeschnitten hat. Ich prüfe bei einem Subset deshalb zuerst, ob ä, ö, ü und ß drin sind.
Einwilligung und Performance
Brauchst du überhaupt einen Banner?
Nicht jede Seite. Eine Einwilligung braucht es nur, wenn eine Seite nicht unbedingt erforderliche Informationen auf dem Endgerät speichert oder ausliest, also bei Tracking, Werbung oder anderen nicht notwendigen Cookies. Diese Pflicht kommt aus § 25 TDDDG (bis 13. Mai 2024 hieß das Gesetz TTDSG), die DSGVO regelt dann, wie die Einwilligung aussehen muss. Eine Seite ohne Tracking braucht keinen Banner, und das ist auch der schnellste Banner.
Wo einer nötig ist, hilft die Orientierungshilfe der Datenschutzkonferenz (Version 1.2, November 2024): Ablehnen auf der ersten Ebene ist nötig, wenn man dort schon zustimmen kann und der Banner die Seite verdeckt. Das ist laut DSK bei den gängigen Bannern “sehr häufig” der Fall (Rn. 124 und 125). Ein Button “Einstellungen”, der erst auf eine zweite Ebene führt, reicht dann nicht (Rn. 137). Für die Performance ist das egal, für den Banner nicht: Zwei gleichwertige Buttons kosten nichts, und ein Banner mit versteckter Ablehnung wird dadurch nicht schneller, nur angreifbarer.
Wo Einwilligung und Performance aneinandergeraten:
- Banner-Bibliotheken bringen oft viel JavaScript mit, und das läuft im kritischen Pfad.
- Analytics und Tracking dürfen erst nach der Einwilligung laden. Das heißt: erst Banner, dann Entscheidung, dann Skript. Weder vorher noch “verzögert” ist ein Ausweg.
- Consent-Management-Plattformen (CMPs) sprechen mit externen Servern, und das kostet Zeit.
- Auch Error-Monitoring und andere “harmlose” Werkzeuge sind nicht automatisch ausgenommen: Speichern sie etwas auf dem Endgerät oder lesen sie dort etwas aus, gilt § 25 TDDDG. Schicken sie personenbezogene Daten wie die IP-Adresse an einen Dienst, brauchen sie nach der DSGVO eine Rechtsgrundlage.
Das Prinzip als Code:
Der Banner aus dem Abschnitt zu CLS oben speichert die Entscheidung unter cookie-consent. Analytics hängt an genau diesem Wert und an sonst nichts:
function loadAnalytics() {
window.dataLayer = window.dataLayer || [];
window.gtag = function () {
dataLayer.push(arguments);
};
const script = document.createElement("script");
script.src = "https://www.googletagmanager.com/gtag/js?id=GA_ID";
script.async = true; // blockiert das Rendern nicht
document.head.appendChild(script);
gtag("js", new Date());
gtag("config", "GA_ID", {
allow_google_signals: false,
allow_ad_personalization_signals: false,
});
}
// Beim Seitenaufruf: nur laden, wenn jemand schon zugestimmt hat
if (localStorage.getItem("cookie-consent") === "accepted") {
loadAnalytics();
}
// Im Banner: `decide()` oben ruft loadAnalytics() erst nach dem Klick auf
// "Alle akzeptieren" auf. Bei "Ablehnen" wird nichts geladen und nichts nachgeladen.Die Optionen bei gtag("config", ...) sind kein Datenschutz-Ersatz. Eine IP-Kürzung (anonymize_ip) gab es in Universal Analytics, GA4 speichert laut Google-Hilfe keine IP-Adressen, die Option bewirkt dort nichts. Rechtlich trägt hier die Einwilligung, nicht die Konfiguration.
Lokale Server und CDNs
Warum der Standort des Servers zählt:
Die physische Entfernung zwischen Server und Nutzer hat Einfluss auf die Ladezeit. Jeder Request muss hin und zurück, und bevor das erste Byte der Seite ankommt, passiert das bei DNS, TCP und TLS gleich mehrfach. Das ist ein Teil der TTFB (siehe oben) und summiert sich über alle Requests einer Seite.
Und die DSGVO?
Für Anbieter aus den USA gilt seit dem 10. Juli 2023 das EU-US Data Privacy Framework, und das Gericht der EU hat am 3. September 2025 eine Klage dagegen abgewiesen (Rechtssache T-553/23, Latombe). Der Kläger hat dagegen Rechtsmittel beim EuGH eingelegt (C-703/25 P), endgültig entschieden ist das also noch nicht. Ist ein Anbieter dort zertifiziert (die Liste steht auf dataprivacyframework.gov) und gibt es einen Auftragsverarbeitungsvertrag, kann ein US-CDN datenschutzrechtlich eingesetzt werden. Ob das bei dir reicht, klärst du am besten mit jemandem, der das beruflich macht, ich bin kein Anwalt. Wer das Risiko scheut, dass das Framework später doch noch kippt, nimmt einen Anbieter aus der EU.
Format und Standort regelt das CDN, nicht dein JavaScript:
Das nächstgelegene Rechenzentrum sucht sich ein CDN selbst aus. Das musst du nicht im Browser nachbauen, und das Bildformat auch nicht: <picture> (siehe oben) reicht, oder ein Bild-CDN, das nach dem Accept-Header des Browsers ausliefert. Ein Skript, das die Bild-URL erst zusammenbaut, hat sogar einen Nachteil: Der Browser entdeckt das Bild später, weil er die URL beim ersten Lesen des HTML nicht sieht, und das kostet LCP.
CDN- und Hosting-Anbieter mit Standorten in Deutschland:
Eine Auswahl, die sich für schnelle Seiten in Deutschland eignet, mit dem Firmensitz dahinter, weil der für die DSGVO eine Rolle spielt:
- Cloudflare (USA): Globales CDN, nach eigenen Angaben mit Rechenzentren unter anderem in Frankfurt und München
- KeyCDN (Schweiz): Europäisches CDN
- bunny.net (Slowenien): früher BunnyCDN
- ALL-INKL (Deutschland): Hoster
- Hetzner (Deutschland): Server und Cloud in Deutschland
Performance-Monitoring für deutsche Websites:
Ein eigenes Monitoring nur für Besucher mit deutscher Sprache oder Zeitzone verzerrt die Daten, und die Erkennung ist ohnehin unscharf. Ich messe lieber alle Besucher und schaue hinterher auf Seite, Gerät oder Land, wenn ich diese Angaben ohnehin habe. Was ein selbstgebauter Monitor mühsam versucht, liefert die Attribution-Variante der web-vitals-Bibliothek gleich mit: das LCP-Element, die Ursache einer trägen Interaktion und das Element hinter dem größten Layout-Shift.
import { onCLS, onINP, onLCP } from "web-vitals/attribution";
function report({ name, value, attribution }) {
// Je Metrik steht in attribution, woran es lag
const element =
attribution.target ??
attribution.interactionTarget ??
attribution.largestShiftTarget;
console.log(name, Math.round(value * 1000) / 1000, element);
}
onLCP(report); // attribution.target: das LCP-Element
onINP(report); // attribution.interactionTarget: das Element der trägsten Interaktion
onCLS(report); // attribution.largestShiftTarget: das Element, das am stärksten gesprungen istWenn der Cookie-Banner dein CLS verursacht, siehst du ihn hier als largestShiftTarget. Wohin du die Werte schickst, ist wieder eine Frage der Einwilligung, wie oben beschrieben.
Monitoring und Wartung
Performance-Optimierung ist nicht einmalig erledigt, sie braucht kontinuierliche Überwachung und Pflege. Genau wie ein Auto regelmäßige Wartung braucht, müssen auch Websites laufend kontrolliert und optimiert werden. Hier erfährst du, wie du deine Website langfristig schnell hältst und Probleme frühzeitig erkennst.
Warum ist kontinuierliches Monitoring so wichtig?
Stell dir vor, du optimierst deine Website und die Core Web Vitals sind perfekt. Drei Wochen später integriert ein Kollege ein neues Plugin, lädt neue Bilder hoch oder ändert das CSS, und schon können deine Performance-Werte wieder schlecht sein. Ohne Monitoring merkst du das erst, wenn es zu spät ist und sich Nutzer bereits beschweren oder die Werte in der Search Console kippen.
Real User Monitoring (RUM)
Real User Monitoring bedeutet, dass du die echten Performance-Daten deiner tatsächlichen Website-Besucher sammelst, nicht nur Testwerte aus dem Labor. Das ist wie der Unterschied zwischen einem Auto auf dem Prüfstand und dem Auto im echten Straßenverkehr.
Was ist der Unterschied zwischen Labor- und Echtwelt-Daten?
Labordaten (wie PageSpeed Insights) testen deine Website unter kontrollierten, immer gleichen Bedingungen. Das ist nützlich für die Entwicklung, aber echte Nutzer haben:
- Verschiedene Internetgeschwindigkeiten (von schnellem Glasfaser bis langsamen mobilen Verbindungen)
- Unterschiedliche Geräte (neue iPhones bis alte Android-Handys)
- Verschiedene Browsern mit unterschiedlichen Fähigkeiten
- Wechselnde Netzwerkbedingungen (schlechter Empfang im Zug, überlastetes WLAN)
Echte Nutzerdaten sammeln, einfach erklärt:
Google pflegt dafür die kleine, kostenlose JavaScript-Bibliothek “web-vitals” (aktuell Version 6). Sie misst die Core Web Vitals deiner echten Besucher und ruft eine Funktion von dir auf, sobald ein Wert vorliegt. Wohin der Wert geht, entscheidest du. Hier ein Beispiel für Google Analytics 4, nach dem Beispiel in der README:
// Web Vitals Library verwenden - das ist kostenlos von Google
import { onCLS, onINP, onLCP } from "web-vitals";
function sendToAnalytics({ name, delta, value, id }) {
// Annahme: gtag() gibt es schon, Analytics wurde also nach der Einwilligung geladen
gtag("event", name, {
value: delta, // delta, damit sich die Werte addieren lassen
metric_id: id, // eindeutige ID dieser Messung, nötig zum Auswerten
metric_value: value,
metric_delta: delta,
});
}
// Diese Zeilen aktivieren die Messung für die drei Core Web Vitals
onCLS(sendToAnalytics); // Misst Layout-Verschiebungen
onINP(sendToAnalytics); // Misst die Reaktionszeit auf Eingaben
onLCP(sendToAnalytics); // Misst Ladezeit des größten ElementsAuch diese Messung geht an Google Analytics und braucht deshalb eine Einwilligung. Wenn du einen anderen Weg nimmst, etwa navigator.sendBeacon() an deinen eigenen Server, gilt das, was ich oben zum Speichern und Auslesen auf dem Endgerät geschrieben habe, trotzdem: Prüf, ob du dabei etwas ins Endgerät schreibst oder personenbezogene Daten überträgst.
Früher gab es hier noch getFID() und getCLS(). Die get-Namen sind seit Version 3 on-Namen, und onFID() ist in Version 5 (Mai 2025) ganz entfallen, nachdem FID keine Core Web Vital mehr war. Mit einer aktuellen Version scheitert der alte Import also schon beim Laden.
Was passiert hier technisch?
Die web-vitals Library läuft unsichtbar im Hintergrund deiner Website. Sie misst die Core Web Vitals jedes Besuchers und ruft deine sendToAnalytics-Funktion auf, sobald eine Messung verfügbar ist. Du bekommst dann Name, Wert und eine ID der Messung, zum Beispiel:
- LCP von 3,2 Sekunden
- CLS von 0,05
Wo der Besucher sitzt oder auf welchem Gerät, liefert die Bibliothek nicht. Das müsstest du selbst mitschicken, und dann gilt wieder das Datenschutz-Thema von oben. Auch die Browser messen nicht alles: CLS gibt es laut README bisher nur in Chromium-Browsern, LCP und INP auch in Firefox und Safari.
Wie interpretierst du die RUM-Daten?
In Google Analytics (oder deinem anderen Analytics-Tool) kannst du dann sehen:
- Welche Seiten die schlechteste Performance haben
- Ob mobile Nutzer schlechtere Werte haben als Desktop-Nutzer
- Wie sich deine Performance über Zeit entwickelt
- Ob bestimmte Gerätetypen oder Browser Probleme haben (wenn du das zu den Messwerten mitschickst)
Zum Beispiel könntest du entdecken: “Unsere Produktseiten haben auf Mobilgeräten einen LCP von 4,5 Sekunden, das ist viel zu langsam!” Dann weißt du genau, wo du optimieren musst.
Einfachere Alternativen zu Google Analytics:
Falls dir Google Analytics zu komplex ist, gibt es einfachere Tools:
- Google Search Console zeigt Core Web Vitals-Daten kostenlos (ebenfalls aus dem Chrome User Experience Report)
- PageSpeed Insights zeigt die CrUX-Daten aus Chrome an (wenn genug Traffic da ist)
- Cloudflare Web Analytics (kostenlos)
- Einfache RUM-Dienste wie SpeedCurve oder Calibre (kostenpflichtig, aber einfach zu verstehen)
Performance Budget
Ein Performance Budget ist wie ein Finanzbudget für deine Website, nur dass du statt Geld die “Kosten” in Ladezeit, Dateigröße und Performance-Werten misst. Es hilft dir dabei, Grenzen zu setzen und nicht versehentlich deine Website zu überlasten.
Warum brauchst du ein Performance Budget?
Ohne Budget passiert oft folgendes: Du optimierst deine Website und sie ist schnell. Dann fügt jemand “nur schnell” ein kleines Feature hinzu, lädt ein paar neue Bilder hoch, installiert ein Plugin. Und plötzlich ist die Website wieder langsam. Ein Performance Budget verhindert das, indem es klare Grenzen definiert.
Praktisches Beispiel eines Performance Budgets:
Als Budget nehme ich die Assertions von Lighthouse CI (die Einrichtung steht weiter unten). Die kennen neben den Zeiten auch Größen, hier in Byte:
// lighthouserc.js (Ausschnitt): das Budget als Assertions
module.exports = {
ci: {
assert: {
assertions: {
"resource-summary:total:size": ["error", { maxNumericValue: 2000000 }], // alles zusammen: 2 MB
"resource-summary:script:size": ["error", { maxNumericValue: 500000 }], // JavaScript: 500 KB
"resource-summary:image:size": ["error", { maxNumericValue: 1000000 }], // Bilder: 1 MB
"resource-summary:stylesheet:size": ["error", { maxNumericValue: 100000 }], // CSS: 100 KB
"largest-contentful-paint": ["error", { maxNumericValue: 2500 }], // LCP: 2,5 Sekunden
"cumulative-layout-shift": ["error", { maxNumericValue: 0.1 }], // CLS: 0,1
"total-blocking-time": ["warn", { maxNumericValue: 300 }], // Stellvertreter für INP
},
},
},
};INP gehört nicht in ein Labor-Budget, den misst man im Feld. Im Labor ist Total Blocking Time der Stellvertreter, laut web.dev ein brauchbarer Hinweis, aber kein Ersatz für INP.
Wie bestimmst du deine Budget-Grenzen?
- Miss deine aktuelle Website mit allen Tools (PageSpeed Insights, Lighthouse, etc.)
- Schaue, welche Werte du aktuell hast
- Setze deine Budgets etwas besser als der aktuelle Zustand, damit sie nicht gleich beim ersten Build reißen
- Wenn deine Website bereits sehr schnell ist, nutze die “guten” Grenzwerte (LCP unter 2,5 s und CLS unter 0,1 im Labor, INP unter 200 ms im Feld)
Wie überwachst du dein Performance Budget?
Build-Tools können automatisch prüfen, ob deine Website die Budget-Grenzen einhält. Webpack bringt dafür eine eigene Grenze mit (performance). Der Bundle Analyzer, den viele dafür nehmen, erzeugt dagegen nur einen Bericht und schlägt nie Alarm. Webpack selbst warnt im Production-Modus ab 250.000 Byte, und mit hints: "error" bricht der Build ab:
// webpack.config.js: Der Build bricht ab, wenn Dateien über dem Budget liegen
module.exports = {
performance: {
hints: "error", // "warning" warnt nur
maxAssetSize: 500_000, // einzelne Datei: 500 KB (Angabe in Byte)
maxEntrypointSize: 500_000, // alles, was ein Einstiegspunkt lädt: 500 KB
},
};Was machst du, wenn das Budget überschritten wird?
- Identifiziere den Übeltäter (welche Datei ist zu groß geworden?)
- Entscheide: Ist das Feature wichtig genug für die Performance-Kosten?
- Wenn ja: Optimiere an anderer Stelle um die Kosten auszugleichen
- Wenn nein: Entferne das Feature oder finde eine leichtere Alternative
Automatisierte Tests
Automatisierte Performance-Tests sind wie ein Wachhund für deine Website: sie testen kontinuierlich die Performance und schlagen Alarm, wenn etwas schlechter wird. Das passiert vollautomatisch ohne dass du daran denken musst.
Warum sind automatisierte Tests wichtig?
Stell dir vor, du baust ein neues Feature und veröffentlichst es auf deiner Website. Ohne automatisierte Tests merkst du erst Tage oder Wochen später, dass das Feature deine Ladezeiten verschlechtert hat. Mit automatisierten Tests bekommst du sofort Bescheid und kannst reagieren, bevor echte Nutzer betroffen sind.
Lighthouse CI (automatisierte Performance-Tests):
Lighthouse CI führt automatisch Lighthouse-Tests durch, wann immer du Code-Änderungen machst:
// lighthouserc.js - Konfigurationsdatei für automatisierte Tests
module.exports = {
ci: {
collect: {
startServerCommand: "npm run start", // LHCI startet den Server selbst und wartet, bis er läuft
url: ["http://localhost:3000"], // Welche URLs getestet werden
numberOfRuns: 3, // 3 Läufe je URL (das ist auch der Standard)
settings: {
chromeFlags: ["--no-sandbox"], // Browser-Einstellungen für Server
},
},
assert: {
assertions: {
// Diese Grenzen dürfen NICHT überschritten werden
"categories:performance": ["error", { minScore: 0.9 }], // Mindestens 90% Performance-Score
"largest-contentful-paint": ["error", { maxNumericValue: 2500 }], // LCP unter 2,5 Sekunden
"cumulative-layout-shift": ["error", { maxNumericValue: 0.1 }], // CLS unter 0,1
"first-contentful-paint": ["error", { maxNumericValue: 1800 }], // FCP unter 1,8 Sekunden
"speed-index": ["error", { maxNumericValue: 3000 }], // Speed Index unter 3 Sekunden
// Warnung bei schlechterem, aber nicht kritischem Wert
// (INP gibt es im Labor nicht, Total Blocking Time ist der Stellvertreter)
"total-blocking-time": ["warn", { maxNumericValue: 300 }], // TBT unter 300ms
},
},
upload: {
target: "temporary-public-storage", // Ergebnisse online verfügbar machen
},
},
};Heißt die Datei lighthouserc.js (oder .cjs, .json, .yml), findet Lighthouse CI sie von selbst. Eine Datei mit anderem Namen gibst du mit --config an. Und was die Einstellungen praktisch bedeuten:
numberOfRuns: 3heißt: jede Seite wird dreimal getestet. Die Assertions nehmen standardmäßig den günstigsten Lauf (optimistic), mitaggregationMethod: "median"den mittleren. Das steht in der Konfigurationsdoku."error"bedeutet: Build schlägt fehl, wenn diese Grenze überschritten wird"warn"bedeutet: Warnung ausgeben, aber Build läuft weitermaxNumericValue: Die Obergrenze für den Messwert der Prüfung, in deren Einheit: Millisekunden bei LCP, FCP, Speed Index und TBT, keine Einheit bei CLS, Byte bei Dateigrößen (beicategories:performanceheißt die GrenzeminScore, ein Wert zwischen 0 und 1)
Integration in GitHub Actions (automatisch bei jedem Code-Update):
# .github/workflows/performance.yml
name: Performance Tests
on: [push, pull_request]
jobs:
performance:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- name: Setup Node.js
uses: actions/setup-node@v7
with:
node-version: "lts/*"
- name: Install dependencies
run: npm install
- name: Build website
run: npm run build
- name: Run Lighthouse CI
# Den Server startet LHCI über startServerCommand aus der lighthouserc.js
run: npx @lhci/cli@0.15.x autorunWas passiert, wenn ein Test fehlschlägt?
- Du bekommst eine E-Mail oder Benachrichtigung “Performance-Test fehlgeschlagen”
- Du siehst genau, welche Metrik das Problem verursacht (z.B. “LCP ist 3,2 Sekunden statt unter 2,5”)
- Du kannst die detaillierten Lighthouse-Reports anschauen
- Du behebst das Problem und versuchst es erneut
Einfachere Alternative: PageSpeed Insights API:
Falls Lighthouse CI zu viel Aufwand ist, kannst du die PageSpeed Insights API direkt abfragen. Google empfiehlt für häufige, automatisierte Abfragen einen API-Schlüssel, deshalb ist er hier schon vorgesehen:
// Einfacher automatisierter Performance-Check (Node.js, wegen fetch)
async function checkPerformance(url) {
const api = new URL(
"https://www.googleapis.com/pagespeedonline/v5/runPagespeed",
);
api.searchParams.set("url", url); // kodiert die Adresse für dich
api.searchParams.set("category", "performance");
if (process.env.PSI_API_KEY) {
api.searchParams.set("key", process.env.PSI_API_KEY);
}
try {
const response = await fetch(api);
if (!response.ok) throw new Error(`HTTP ${response.status}`);
const data = await response.json();
const score = data.lighthouseResult.categories.performance.score * 100;
const lcp =
data.lighthouseResult.audits["largest-contentful-paint"].numericValue;
const cls =
data.lighthouseResult.audits["cumulative-layout-shift"].numericValue;
console.log(`Performance Score: ${score}/100`);
console.log(`LCP: ${lcp}ms`);
console.log(`CLS: ${cls}`);
// Automatische Warnung bei schlechten Werten
if (score < 90) {
console.error(`❌ Performance-Score zu niedrig: ${score}/100`);
}
if (lcp > 2500) {
console.error(`❌ LCP zu langsam: ${lcp}ms (sollte unter 2500ms sein)`);
}
if (cls > 0.1) {
console.error(`❌ CLS zu hoch: ${cls} (sollte unter 0.1 sein)`);
}
return { score, lcp, cls };
} catch (error) {
console.error("Fehler beim Performance-Check:", error);
}
}
// Alle wichtigen Seiten testen
checkPerformance("https://deine-website.de/");
checkPerformance("https://deine-website.de/blog/");
checkPerformance("https://deine-website.de/produkte/");Die Werte kommen hier aus dem Lighthouse-Lauf im Labor. Felddaten stehen derzeit noch unter loadingExperience, wenn für die Seite genug CrUX-Daten da sind. Google will sie aber aus dieser API nehmen und empfiehlt dafür die CrUX API.
Praktische Tipps für Einsteiger:
- Beginne mit einfachen Tools (PageSpeed Insights, Google Search Console)
- Setze zuerst nur ein Performance Budget für die wichtigsten Werte (LCP, CLS)
- Automatisiere Tests erst wenn du die manuellen Tests verstehst
- Starte mit Warnungen statt harten Fehlern und lerne erstmal die Schwankungen kennen
- Teste wichtige Seiten mehrmals die Woche, nicht nur bei Code-Änderungen
Mit diesem kontinuierlichen Monitoring stellst du sicher, dass deine Website langfristig schnell bleibt und du Performance-Probleme erkennst, bevor sie deine Nutzer beeinträchtigen.
Fazit
Core Web Vitals messen, wie sich eine Seite für Besucher anfühlt: wie schnell der Hauptinhalt da ist, wie schnell sie auf Eingaben reagiert und ob sie stillhält. Google nutzt sie auch in der Suche, verspricht für gute Werte aber ausdrücklich keine Top-Platzierung. Als deutsche Entwickler stehen wir vor besonderen Herausforderungen: längere Wörter, Cookie-Banner nach deutschem Recht und spezifische Nutzergewohnheiten erfordern eine durchdachte Performance-Strategie.
Die drei Säulen erfolgreicher Core Web Vitals Optimierung:
- LCP unter 2,5 Sekunden: Durch moderne Bildformate, optimierte Ladestrategien und schnelle Server-Antworten
- INP unter 200ms: Durch intelligentes JavaScript-Loading, Code-Splitting und Third-Party-Script-Optimierung
- CLS unter 0,1: Durch feste Größenangaben, optimiertes Font-Loading und DSGVO-konforme Banner-Implementierung
Besondere Erfolgsfaktoren für deutsche Websites:
- Deutsche Typografie: Längere Wörter erfordern spezielle Layout-Überlegungen
- Einwilligung: Wer Tracking einsetzt, braucht einen Banner, und der darf weder Inhalt verschieben noch beim Ablehnen schlechter gestellt sein
- Lokale Infrastruktur: Deutsche CDNs und Server-Standorte nutzen
- Real User Monitoring: Echte Nutzerdaten sammeln, nicht nur Laborwerte verwenden
Dein Weg zum Erfolg:
- Messen: Starte mit einer gründlichen Analyse deiner aktuellen Performance
- Priorisieren: Fokussiere dich auf die größten Optimierungspotentiale
- Implementieren: Setze die Maßnahmen systematisch um
- Überwachen: Etabliere kontinuierliches Monitoring mit Performance Budgets
- Iterieren: Performance-Optimierung ist ein laufender Prozess
Performance ist kein einmaliges Projekt, sondern läuft mit. Mit den richtigen Tools, Techniken und einem systematischen Vorgehen bekommst du eine Website, die schnell lädt und es auch bleibt. Ob Google das mit besseren Plätzen belohnt, kann ich dir nicht versprechen, das sagt Google selbst auch nicht. Deine Besucher merken es trotzdem.
Weitere Blog Artikel
4 ArtikelNewsletter
einmal die Woche, kostenlosNeue Artikel und Videos, was sich auf der Lernplattform tut, und ab und zu ein Sonderpreis zum Kursstart. Kurz genug, dass du es auch liest.
Zuletzt verschickt · KW 47
Lektionen jetzt auch mit Video