React is slow, what now?

V8 Engine and JavaScript Optimization Tips

How to read a Web Page Test waterfall chart

Improve Performance by Understanding Your User

State Colocation will make your React app faster

Wikipedia’s JavaScript initialization on a budget

“Preloading a font even when I shouldn’t have to”

Performance metrics for blazingly fast web apps

Profile a React App for Performance

Investigate animation performance with DevTools

A lighter V8

Using Webpack Analyzer & React Lazy

Fix the slow render before you fix the re-render

How Web Content Can Affect Power Usage

Less Data Doesn’t Mean a Lesser Experience

Faster Image Loading With Embedded Image Previews

Native lazy-loading for the web

Using Native JavaScript Modules in Production Today

Time to First Byte: what it is and why it matters

Developing a Robust Font Loading Strategy

Why is my webpack build slow?

Are long JavaScript tasks delaying your Time to Interactive?

React Performance and Multi-Threading

Measuring Interactivity with TTI

Comparing JVM alternatives to JavaScript

Optimizing Performance with Resource Hints

Lazy Parsing in V8

Measuring Animation Performance

“How we used WebAssembly to speed up our app”

Who has the fastest website in F1?

Cache-Control for Civilians

Making Google Fonts Faster

Performance Implications of Polymorphism

Server-Side Caching in Express

Progressive React

Replacing a hot path in your app’s JavaScript with WebAssembly

Preloading Fonts and the Puzzle of Priorities

Resource Prioritization for the Web

Speed up Navigation with Prefetching

Modernizing Netflix’s Web Playback UI

JavaScript Growth and Third Parties

Measuring the Performance Impact of Chrome Extensions

HTTP/2 Prioritization

Using CSS to Load Web Fonts?

Avoiding The Pitfalls of Inlined Code

Inlining or Caching? Both Please!

Faster Async Functions and Promises in V8

CSS and Network Performance

Fast Load Times

A Netflix Web Performance Case Study

Three Types of Performance Testing

Web Performance 101

Array destructuring for multi-value returns

The Intl.RelativeTimeFormat API

Start Performance Budgeting

Profiling with the User Timing API

Avoid Unnecessary Renders in React

Eliminate Common React Performance Issues

Analysis of Chromium’s Paint Timing Metrics

Calls between JavaScript and WebAssembly are finally fast

Accurately Measuring Layout on the Web

Idle Until Urgent

You Probably Don’t Need Moment.js

Cache React Event Listeners

Improving Client-Side Performance

Diagnosing React Performance Issues

Reduce JavaScript Payloads with Code Splitting

Wormholes in JavaScript

Web Performance Made Easy

Optimizing Prototypes for JavaScript Engines

Native Lazy Load for the Web Platform

How Service Workers Improve Performance

Browser Paint & Web Performance

Node.js Performance and Flame Graphs

Tools, Techniques, Tips for Performant Node

How and When Browsers Download Images

Guess — Data-driven bundling for the Web

Replace an Animated GIF with Video

Making High Quality Video Efficient at YouTube

Improved Code Caching in V8

Find out the cost of new dependencies

Optimizing Load Times With the Chrome DevTools

Notes on Making Pinterest Fast

Impact of Polymorphism on Component-based Frameworks

Lighter than Lightweight: Preact vs Glimmer

Three Techniques for Performant Custom Font Usage

Loading Third-Party JavaScript

Maybe you don’t need Rust and WASM to speed up your JS

Front-End Performance Checklist

Rendering Metrics

Recent web performance fixes on Airbnb listing pages

HTTP/2 push vs preload

The Cost of JavaScript

How 3rd Party Scripts can be performant citizens on the web

Ending the debate on inline functions in React

Real-world Web Performance Budgets

Lazy Unlinking of Deoptimized Functions

React, Inline Functions, and Performance

“Elements kinds” in V8