Advanced web performance engineering
You analyse bottlenecks end to end, from server response time to cache layers and from the critical path to rendering strategies, and prove improvements with experiments.
Level 501 · 13 lessons · 12 practice labs
Lessons
End-to-end analysis
- Critical path analysis
- Server time with TTFB and Server-Timing
- Connection costs: DNS, TLS and connection reuse
- Short task: find which layer is slow
Rendering strategies
- Server, client and static rendering
- The cost of hydration
- Streaming HTML
- Speculation rules
- Short task: measure one page with three strategies
Proving it
- Performance experiments and comparison
- Catching performance regressions in continuous integration
- Analysing field data with percentiles
- Capstone: a performance audit and roadmap for an application
Practice labs
- Break down time with Server-Timing: Add database, template and cache durations to a slow endpoint with the Server-Timing header and read them in the browser.
- Cut the connection cost of four domains: Measure DNS and TLS times on a page pulling from four domains and reduce them with consolidation and preconnect.
- Shorten the critical request chain: Flatten a chain where CSS, a font and an image wait on each other with preloads and inline critical styles, and measure the gain.
- Measure the cost of hydration: Work out from a profile how long hydration takes on the main thread for a server-rendered product page.
- Stream HTML without waiting for a slow section: Turn a page that waits for a slow recommendations section into a streamed response that sends the header and main content first.
- Speed up navigation with speculation rules: Prerender the most-clicked products from a category page with speculation rules and limit wasted load.
- Lower TTFB with a page cache: Add a short-lived cache to a category page that hits the database on every request and measure the drop in TTFB.
- Reuse upstream connections: Enable a keepalive pool on a proxy that opens a new upstream connection per request and compare the latency distribution.
- Prevent a cache stampede: Add single-flight locking and early refresh to a page where hundreds of requests hit the database when the cache expires.
- Report field data with percentiles: Compute p50, p75 and p95 instead of the mean from a week of field LCP data and explain why they differ.
- Catch a performance regression in CI: Set up a performance check that takes repeated measurements on each merge request and warns when a threshold is crossed.
- Evaluate an A/B performance experiment: Show statistically whether the difference in an experiment comparing two image strategies is real or noise.
About this course
You analyse bottlenecks end to end, from server response time to cache layers and from the critical path to rendering strategies, and prove improvements with experiments.
What you will learn
- End-to-end analysis
- Rendering strategies
- Proving it
Prerequisites
You should be experienced in the topics of the same path up to level 401.
Lab environment
Lessons run in your own Kali Linux terminal in the browser, connected to a private lab network. Nothing to install.
Frequently asked questions
- Is this course right for my level?
- The course is at level 501; it assumes you know the topics of the lower-level courses.
- Is there anything to install?
- No. Every lesson runs in your own lab environment that opens in the browser.
- How do lessons work?
- Each lesson has 8 to 10 steps and a short quiz. Early steps show the command to type, later steps give less help; if two attempts fail, the solution opens.
- Can I try it for free?
- Yes. The first three lessons of every course are free.