Backend
Materialized Views in Postgres: Aktualität gegen Geschwindigkeit eintauschen
Wie du materialized views nutzt, um teure Aggregationen in Postgres zu beschleunigen, ohne deinen Nutzern unbemerkt veraltete Daten auszuliefern.
·5 Min. Lesezeit
Tags
performance
44 Artikel
Engineering
Cancellation-Patterns in TypeScript: AbortController gezähmt
Warum der Großteil des asynchronen TypeScript-Codes Cancellation komplett ignoriert, und wie man mit AbortController komponierbares, leckfreies Abbrechen aufbaut.
·4 Min. Lesezeit
Backend
Request Coalescing: den Thundering Herd in Node.js verhindern
Wenn ein Cache-Eintrag bei hoher Last abläuft, wetteifern Dutzende Anfragen gleichzeitig darum, ihn neu aufzubauen. So verwandelt Request Coalescing – die Deduplizierung gleichzeitig laufender Anfragen – diesen Ansturm in einen einzigen Aufruf an das Backend.
·4 Min. Lesezeit
Backend
Volltextsuche in Postgres: Elasticsearch ist in den meisten Fällen überflüssig
Postgres verfügt über eine leistungsstarke integrierte Volltextsuche auf Basis von tsvector, tsquery und GIN-Indizes — für die meisten Anwendungen ist kein Elasticsearch-Cluster nötig.
·4 Min. Lesezeit
Backend
Große Datenmengen in Node.js streamen: Backpressure und asynchrone Generatoren
Schluss mit dem vollständigen Laden von Ergebnismengen in den Speicher: Wie Node.js-Streams und asynchrone Generatoren es ermöglichen, Millionen von Datensätzen zu verarbeiten, ohne den Heap zu sprengen.
·5 Min. Lesezeit
Backend
Asynchrone Nebenläufigkeitssteuerung in Node.js: Semaphore, Throttling und Backpressure
Ein unbegrenztes Promise.all ist ein stiller OOM-Killer — so baust du Semaphore, gedrosselte Queues und Stream-Backpressure in deine Node.js-Anwendungen ein.
·5 Min. Lesezeit
Backend
Das DataLoader-Muster: N+1-Abfragen ohne ORM eliminieren
N+1 ist kein ORM-Problem: lerne, wie du das DataLoader-Batching-Muster in TypeScript implementierst, um redundante Datenabfragen über jede Datenquelle hinweg zusammenzufassen – auch Microservices.
·4 Min. Lesezeit
Backend
HTTP-Caching entmystifiziert: Cache-Control, ETags und CDN-Strategien
Ein praxisnaher Leitfaden zu HTTP-Caching-Headern — was jede Direktive wirklich bewirkt, wann ETags sinnvoll sind und wie du aufhörst, gegen dein CDN zu kämpfen.
·5 Min. Lesezeit
Backend
Worker Threads in Node.js: CPU-intensive Arbeit auslagern, ohne den Event Loop zu blockieren
Erfahre, wie du mit Worker Threads in Node.js CPU-intensive Aufgaben verarbeitest, ohne den Event Loop zu blockieren – mit Thread-Pooling und typsicheren Messaging-Patterns.
·5 Min. Lesezeit
Frontend
React-Performance-Optimierung: Patterns, die wirklich etwas bewirken
Praktische Performance-Techniken für React — Memoisierung, Virtualisierung, Code-Splitting und Profiling — mit echten Vorher-Nachher-Benchmarks und den Kompromissen jedes Ansatzes.
·3 Min. Lesezeit
Backend
Datenbank-Designfehler, die ich in jeder Codebase sehe (und wie man sie behebt)
Die wiederkehrenden Datenbank-Designfehler, die langsame Abfragen, schmerzhafte Migrationen und Produktionsvorfälle verursachen — mit praktischen Lösungen und der Begründung hinter jedem einzelnen.
·4 Min. Lesezeit
Frontend
Optimistische UI-Updates: reaktionsschnelle Oberflächen mit Rollback
Implementiere optimistische UI-Updates, die deine Anwendung sofort reagieren lassen, indem der erwartete Zustand direkt angezeigt, anschließend mit der Serverantwort abgeglichen und bei fehlgeschlagenen Mutationen sauber zurückgesetzt wird.
·4 Min. Lesezeit
Frontend
Server Components und Client Components: Wann welche in Next.js verwenden
Verstehen Sie das mentale Modell zur Wahl zwischen Server Components und Client Components in Next.js – die Rendering-Grenze, Serialisierungsbeschränkungen und Kompositionsmuster, die bestimmen, wo Code ausgeführt wird.
·4 Min. Lesezeit
Backend
Datenbank-Connection-Pooling: Optimierung für Performance unter Last
Ein tiefgehender Blick auf die Konfiguration von Datenbank-Connection-Pools: Formeln zur Pool-Dimensionierung, Verwaltung des Verbindungslebenszyklus, Health-Check-Strategien und die Diagnose von Pool-Erschöpfung unter produktiven Lastmustern.
·4 Min. Lesezeit
Frontend
WebAssembly für Webentwickler: praktische Anwendungsfälle jenseits des Hypes
Ein nüchterner Blick darauf, wo WebAssembly in Webanwendungen tatsächlich Mehrwert bringt – von Bildverarbeitung über Kryptografie bis zur Datentransformation – sowie darauf, wann JavaScript weiterhin die bessere Wahl ist.
·4 Min. Lesezeit
Tutorials
Eine Volltextsuchmaschine mit Elasticsearch und Node.js bauen
Ein Schritt-für-Schritt-Tutorial zur Implementierung einer Volltextsuche mit Elasticsearch mit Indexdesign, Analyzern, Fuzzy-Matching, Facettensuche und Mustern zur Performance-Optimierung.
·4 Min. Lesezeit
Backend
Connection-Pooling-Strategien für Node.js-Anwendungen mit hohem Durchsatz
Ein tiefgehender Blick auf Datenbank-Connection-Pooling für Node.js-Services: Pool-Dimensionierung, Health Checks, Failover-Muster und die häufigen Fehlkonfigurationen, die Produktionsausfälle verursachen.
·6 Min. Lesezeit
Frontend
WebAssembly für JavaScript-Entwickler: praktische Anwendungsfälle
Praktische WebAssembly-Anwendungsfälle für JavaScript-Entwickler: von Bildverarbeitung und Datenkompression bis zu kryptografischen Operationen, mit klaren Beispielen dafür, wann Wasm die Performance verbessert und wann JavaScript bereits schnell genug ist.
·6 Min. Lesezeit
Frontend
CSS Scroll-Driven Animations: Jenseits von JavaScript-Scroll-Handlern
Baue performante scroll-gekoppelte Animationen mit der CSS-API für scrollgesteuerte Animationen – mit praktischen Beispielen für Scroll-Fortschritts-Timelines, View-Timelines, Parallax-Effekte und Sticky-Header-Transformationen, die vollständig abseits des Main Threads laufen.
·4 Min. Lesezeit
Engineering
Lasttest-Strategien: Belastungsgrenzen finden, bevor die Nutzer es tun
Entwirf und führe wirksame Lasttests mit k6 durch – mit praktischen Mustern für Ramping-Strategien, realistische Nutzersimulation, schwellenwertbasierte Bestehen/Durchfallen-Kriterien und Ergebnisinterpretation, um Engpässe zu finden, bevor Produktionstraffic sie aufdeckt.
·5 Min. Lesezeit
Backend
Connection-Pooling-Strategien für Anwendungen mit hohem Durchsatz
Konfiguriere und optimiere Datenbank-Connection-Pools für Node.js-Anwendungen mit hohem Durchsatz – mit praktischen Beispielen zu Pool-Größe, Health Checks, Verbindungs-Lifecycle-Management und typischen Fallstricken, die zu Pool-Erschöpfung führen.
·5 Min. Lesezeit
Frontend
Responsive Bilder richtig gemacht: srcset, sizes und moderne Formate
Meistern Sie die Auslieferung responsiver Bilder mit praktischen Beispielen zu srcset, sizes, dem picture-Element und modernen Formaten wie AVIF und WebP, um die Ladeleistung der Seite drastisch zu verbessern, ohne auf visuelle Qualität zu verzichten.
·5 Min. Lesezeit
Frontend
SSR-Muster und ihre Performance-Kompromisse
Ein Überblick über SSR-Architekturmuster wie streaming SSR, selektive Hydration, Insel-Architektur und partielles Prerendering – mit konkreten Performance-Messungen und Entscheidungshilfen für die Wahl des richtigen Ansatzes.
·5 Min. Lesezeit
Backend
Effiziente Paginierung für große Datensätze entwerfen
Vergleicht Offset-, Cursor- und Keyset-Paginierung anhand praktischer Implementierungen mit ihren Leistungsmerkmalen, Trade-offs und dem passenden Einsatzgebiet für dein API-Design.
·4 Min. Lesezeit
Backend
Verteilte Caching-Muster: Konsistenz, Invalidierung und Fehlermodi
Beherrsche verteilte Caching-Muster einschließlich Cache-Aside, Write-Through, Read-Through und Invalidierungsstrategien, die echte Konsistenzherausforderungen bewältigen.
·5 Min. Lesezeit
Frontend
Performance von Web-Animationen: GPU-beschleunigte Techniken für butterweiche 60 fps
Beherrsche GPU-beschleunigte CSS- und JavaScript-Animationstechniken, die konstant 60 fps liefern, ohne Layout Thrashing oder ruckelnde Frame-Einbrüche zu verursachen.
·5 Min. Lesezeit
Architektur
Edge-Computing-Architekturmuster für Webanwendungen
Entdecke Edge-Computing-Muster, die Berechnungen näher an Nutzer bringen, Latenz reduzieren und neue Möglichkeiten für moderne Webanwendungen und APIs eröffnen.
·5 Min. Lesezeit
DevOps
Leitfaden zu Ressourcen-Requests und -Limits in Kubernetes
Wie man CPU- und Speicher-Requests und -Limits in Kubernetes richtig konfiguriert – und dabei OOMKills, CPU-Drosselung und verschwendete Cluster-Kapazität vermeidet, mit praxisnahen Strategien zur richtigen Dimensionierung.
·5 Min. Lesezeit
Frontend
WebAssembly für Webentwickler verstehen
Eine praxisnahe Einführung in WebAssembly für Webentwickler — was es ist, wann es sich gegenüber JavaScript lohnt, wie man es aus Rust und C kompiliert und wie man Wasm-Module in Webanwendungen integriert.
·4 Min. Lesezeit
Frontend
Bildoptimierung für Web-Performance
Ein praktischer Leitfaden zur Bildoptimierung im Web – moderne Formate, responsive Bilder, Lazy Loading, CDN-Auslieferung und wie sich die Wirkung auf die Core Web Vitals messen lässt.
·5 Min. Lesezeit
Engineering
Lasttests für deine API: Tools, Muster und Fallstricke
Ein praktischer Leitfaden für Lasttests von APIs: Auswahl der richtigen Tools, realistische Traffic-Muster, Performance-Baselines, Identifikation von Engpässen und häufige Fehler.
·4 Min. Lesezeit
Backend
Redis-Datenstrukturen jenseits von Key-Value
Entdecke Redis-Datenstrukturen jenseits einfacher Strings — Sorted Sets für Ranglisten, Streams für Ereignisprotokolle, HyperLogLog für Kardinalität und Bitmaps für Feature Flags.
·5 Min. Lesezeit
Backend
Verwaltung von Datenbankverbindungen in der Produktion
So konfigurierst und überwachst du Datenbank-Connection-Pools — von der Pool-Dimensionierung über Leak-Erkennung und Failover-Handling bis hin zu typischen Fehlkonfigurationen.
·5 Min. Lesezeit
Engineering
Memory-Probleme in Produktionssystemen debuggen
Techniken zur Diagnose von Memory Leaks, übermäßiger Allokation und OOM-Kills in Produktion — mit Heap Snapshots, Profiling-Tools und gängigen Leak-Patterns.
·4 Min. Lesezeit
Architektur
Concurrency-Modelle verstehen: Threads, Async und Actors
Ein Vergleich der Concurrency-Modelle Threads, async/await und Actor-basiert — wann welches passt, welche Tradeoffs sie haben und wie man typische Fallstricke vermeidet.
·5 Min. Lesezeit
Frontend
Code-Splitting-Strategien für schnellere Webanwendungen
Praktische Code-Splitting-Techniken mit Webpack und dynamischen Imports, um die anfängliche Bundle-Größe zu reduzieren und die Ladeperformance der Seite zu verbessern.
·5 Min. Lesezeit
Backend
SQL-Abfrageoptimierung: von langsamen Abfragen zu schnellen Ergebnissen
Praktische Techniken zum Erkennen und Beheben langsamer SQL-Abfragen mit EXPLAIN-Plänen, Indexierungsstrategien und Mustern zur Umstrukturierung von Abfragen.
·5 Min. Lesezeit
Frontend
Performance-Budgets: Web-Performance-Standards festlegen und durchsetzen
Wie Sie Performance-Budgets definieren, messen und durchsetzen, um zu verhindern, dass Ihre Webanwendung mit der Zeit unbemerkt langsamer wird.
·3 Min. Lesezeit
DevOps
Cold Starts bei Serverless: Ursachen, Kosten und Gegenmaßnahmen
Cold Starts sind die versteckte Steuer des Serverless-Modells — ein Überblick über ihre Ursachen, ihre Kosten in Latenz und praktische Strategien, um Funktionen warmzuhalten.
·3 Min. Lesezeit
Engineering
Memory Leaks in Node.js: Erkennung und Vermeidung
Closures, Event-Listener und nicht bereinigte Timer sind die häufigsten Memory-Leak-Muster in Node.js — so findest du sie, bevor sie die Produktion zum Absturz bringen.
·3 Min. Lesezeit
Backend
Connection Pooling: Warum jedes Backend es braucht
Für jede Anfrage eine neue Datenbankverbindung zu öffnen ist ein stiller Performance-Killer — Connection Pools lösen das Problem mit einem verwalteten Satz wiederverwendbarer Verbindungen.
·3 Min. Lesezeit
Backend
Datenbankindizierung: ein Deep Dive
Indizes können die Performance deiner Anwendung machen oder brechen — so funktionieren sie unter der Haube und wann man welchen Typ einsetzt.
·3 Min. Lesezeit
Backend
Caching-Strategien für Webanwendungen
Von HTTP-Headern bis zu Redis-Mustern — ein praktischer Leitfaden zu Caching-Schichten, die Latenz und Datenbanklast reduzieren, ohne veraltete Daten auszuliefern.
·3 Min. Lesezeit
Engineering
Die JavaScript Event Loop verstehen
Die Event Loop ist der Motor hinter jeder asynchronen Operation in JavaScript — so funktioniert sie wirklich, jenseits der oberflächlichen Erklärungen.
·3 Min. Lesezeit