completefrontend
Open lab My progress
THE WEB PERFORMANCE FIELD GUIDE

Writing an audit report

Turn a performance audit into a report people act on: the answer first, the right evidence for each claim, an owner and a day for each fix, and a follow-up.

By the end, you can
  • 01
    Put the answer firstStart with what's wrong, what to do, what it costs and what you need, then give findings, actions with an owner and a day, and the check.
  • 02
    Prove each claimPick the evidence that answers each claim: a p75 for how many, a trace for why, and a before-and-after filmstrip for what visitors will see.
  • 03
    Write for each reader, and follow upWrite the same finding for an engineer and for a manager, then check the fix in the lab and the field, and keep it with a budget and an alert.

Why did nobody act on Ravi's list?

Ravi looks after the Leaf and Kettle's website. Last week he audited it, in lesson 40.1. He read real visits, found the slow pages, and measured six fixes. On Friday he sent the result to two people. Meera builds the shop's pages. The owner runs the shop and decides where time goes.

Here is the message he sent:

Ravi's list, as he sent itPop out in the code editor (opens in a new tab)JavaScript
// Ravi's list, as he sent it: each fix and the visits it helps per hourconst list = [  ["Show the teas, then rank them", 17.5],  ["Send a smaller home photo", 10],  ["Show the count, then the total", 6],  ["Put the offer in the HTML", 5.3],  ["Load the home photo first", 4],  ["Rank the teas on the server", 1.5],];list.forEach(([fix, perHour], i) => console.log(`${i + 1}. ${fix}: ${perHour}`));
  • Line 1 is a comment.
  • Lines 3 to 8 hold the six fixes, best first. Each number is how many slow visits the fix would bring under Google's line, for every hour of work.
  • Line 10 prints them, one per line, from 1. Show the teas, then rank them: 17.5 down to 6. Rank the teas on the server: 1.5.

Every number in it is right. A week later, nothing had changed. The owner wrote back: "What do these numbers mean? Is this urgent? What do you need from me?" Meera wrote too: "Which photo? How big should it be? How do I see the problem myself?"

Why it matters: the audit found the right fixes, but a list that nobody can act on fixes nothing. So what should Ravi have sent? A report: the same findings, written so that each reader can act. Here is the shape of the one he writes in this lesson:

Ravi's report in five parts, top to bottom: Summary: the answer; Findings, each with proof; Actions: who, and which day; How we'll know it worked; How we measured. An arrow from the owner points at the summary. A dashed line beside all five parts is labelled: Meera reads it all.reportSummary: the answerFindings, each with proofActions: who, and which dayHow we'll know it workedHow we measuredthe ownerreads the startMeerareads it all
Ravi's report, top to bottom. The owner may stop after the summary, so it holds the answer. Meera reads it all, down to how he measured.
Real-life analogyA plumber's note and a plumber's quote

Your kitchen tap drips. One plumber looks at it and leaves a note: "washer, valve, 2 h". Another leaves a quote: "The tap drips because its washer is worn. Here is a photo. A new one takes an hour and costs £40. I can come on Tuesday." You say yes to the second one the same day.

In real life: The note: "washer, valve, 2 h"
In a report: Ravi's list: right, but only he can read it
In real life: "The tap drips because its washer is worn"
In a report: A finding: what's wrong, and why
In real life: The photo of the worn washer
In a report: The evidence for the finding
In real life: "One hour, £40, on Tuesday"
In a report: An action, with its cost, its owner and its day
The main idea

An audit report is the audit, written for the people who must act on it. It starts with the answer: what's wrong, what to do, what it costs, and what you need from the reader. Then it gives the proof for each finding, a name and a day for each fix, and the check that will show it worked.

The next four sections build Ravi's report, one part at a time.

How the course recorded it

  • The audit: every number comes from lesson 40.1's recording. That's 320 visits to Ravi's five pages, then lab loads: loads on the course's computer in Chrome 157, set up as Asha's phone. They use DevTools' Slow 4G network and a CPU 4× slower.
  • The fixed home page: this lesson adds 5 more lab loads of the home page with both photo fixes. They ran in the same Chrome, with the same setting, after one load that wasn't kept. Their screenshots are the "with the fix" frames below. LCP is the moment the biggest image or text appears: here, the photo. Their middle LCP was 1,316 ms, and the audit's was 1,304 ms.
  • Ravi's notes: the audit's home trace, saved with two notes the way DevTools' Performance panel saves them.

Put the answer first

Ravi's first draft of the report told the audit in the order he did it, with his request at the very end. Most readers need the opposite order. Google's technical writing course says it plainly: "Imagine that your peers might only read the first paragraph of your document." So the start has to answer their main questions.

Real-life analogyThe front page of a newspaper

On the bus, you glance at a newspaper. The headline says what happened. The first paragraph says who, where and when. You get off at your stop, and you know the news. The rest of the story is there for anyone who wants more.

In real life: The headline
In a report: The report's first line: the problem, with one number
In real life: The first paragraph
In a report: The summary: what to do, what it costs, the decision
In real life: The rest of the story
In a report: Findings, actions, and how we measured
In real life: Getting off at your stop
In a report: The owner, who may read three lines

web.dev's case studies work this way. Vodafone's opens with its result: a 31% better LCP brought 8% more sales. How they did it comes after.

The report's skeleton

Ravi starts from five headings, in the order a reader needs them:

The skeleton of Ravi's reportText
# Speed audit: the Leaf and Kettle shop## SummaryWhat's wrong, what to do, what it costs, and what we need from you.## FindingsEach problem: who it hurts, how we know, and why it happens.## ActionsEach fix, ranked: who does it, and the day after this report it's due.## How we'll know it workedThe number to check, its target, and when we'll read it.## How we measured: the visits, the lab setting, and the files
  • Line 1 is the title.
  • Lines 2 and 3 are the summary. It answers the reader's questions before they ask them.
  • Lines 4 and 5 hold the findings. Each says who it hurts, how we know, and why it happens.
  • Lines 6 and 7 hold the actions, ranked. Each one has a name and a day.
  • Lines 8 and 9 say how we'll know it worked.
  • Line 10 is how Ravi measured. It comes last, because only engineers need it.

The same course adds two habits for the top of a document. Say what it covers, and say who it's for. Ravi writes: "This report covers how fast our five pages are, on phones and computers. It's for Meera and for you. It doesn't cover our place in Google's search results." The owner asked about that once, so it's worth saying it isn't here.

Now see why the order matters. Choose how many lines the owner reads, and compare the two ways to start:

Playground: how far does the owner read?
Answer first
  1. A third of our visits meet a slow or jumpy page: 106 of 320, almost all on phones.
In the order Ravi worked
  1. I collected 320 visits to our five pages, on phones and computers.
The owner's three questions
  1. How bad is it?answer first: line 1; Ravi's order: not yet
  2. What will it cost?answer first: not yet; Ravi's order: not yet
  3. What do you need from me?answer first: not yet; Ravi's order: not yet
Try it yourself
After 1 line: answer first, 1 of 3 questions; Ravi's order, 0 of 3

The owner has three questions. Each row says which line answers it in each version: the answer first, then the order Ravi worked in.

The start of Ravi's report, written two ways from the same audit.

With the answer first, three lines are enough for the owner to decide. In the order Ravi worked, she has to read to the very end. And even then, she never learns how many visits are hurt. Why it matters: busy readers stop early, so put what they need where they stop.

Every action gets a name and a day

A job with no name next to it is like a chore on the fridge list that nobody signed: it's still there on Sunday. So each action in the report says who does it. It also says when, as a day after the report: day 2, day 5. Everyone can count from the day it arrives.

The report's actions, first draftPop out in the code editor (opens in a new tab)JavaScript
// The report's actions: what, who does it, and the day after the report it's dueconst actions = [  { what: "Tea list: show the teas, then rank them", who: "Meera", day: 2 },  { what: "Home: smaller photo, loaded first", who: "Meera", day: 5 },  { what: "Cart: show the count, then the total", who: "Meera", day: 7 },  { what: "Reviews: put the offer in the HTML", who: "", day: 7 },];for (const { what, who, day } of actions) {  console.log(who ? `Day ${day}, ${who}: ${what}` : `No owner yet: ${what}`);}
  • Lines 3 to 6 hold the four actions, ranked by visits helped per hour, each with a name and a day.
  • Line 6 has no name yet.
  • Lines 8 to 10 print each action. One with no name prints a warning instead.
  • The first two lines it prints are Day 2, Meera: Tea list: show the teas, then rank them and Day 5, Meera: Home: smaller photo, loaded first.
  • Then come Day 7, Meera: Cart: show the count, then the total and No owner yet: Reviews: put the offer in the HTML.

Ravi takes the offer himself, for day 7. The home photo action joins two of the audit's fixes: a smaller photo, and loading it first. The last fix, "Rank the teas on the server", goes under "Not now", with its reason. It helps the same visits as the day 2 fix, for 12 times the work. Writing the reason down saves the next reader from asking again.

Show the proof each claim needs

A report makes claims. Each claim needs evidence: something the reader can check for themselves. Ravi's report makes three:

  • Many phone visitors wait too long for the home photo.
  • The photo is late because the file is too big and starts late.
  • With the fix, the photo appears about 5 seconds sooner.

He has three kinds of evidence. Which one proves which claim?

Real-life analogySelling a used car

You're selling your car. One buyer asks if it looks good, so you send a photo. Another asks if it was looked after, so you show the service book. A third asks how far it has been driven, so you read the number on the dashboard. The photo can't answer the third buyer.

In real life: A photo of the car
In evidence: A filmstrip: what a visitor sees
In real life: The service book
In evidence: A trace: what happened inside, and why
In real life: The number on the dashboard
In evidence: A p75: how long real visits waited, and how many
In real life: "The photo doesn't show the miles"
In evidence: Each claim needs the evidence that answers it

A filmstrip shows what visitors see

A filmstrip is a row of screenshots taken while a page loads. Anyone can read one, with no terms to learn. web.dev's "Why does speed matter?" uses one: the same page on a slow and a fast connection, one row above the other.

Ravi puts two rows together. Both are lab loads on Asha's phone, with the same network and the same CPU. Only the page changed. The top row is the home page as it is. The bottom row has both photo fixes. Each column is one moment:

The home page loading in the lab, before the fix and with it, at four moments. At 1,319 ms: before, the words; with the fix, the whole photo. At 2,500 ms: before, a strip of the photo; with the fix, the whole photo. At 4,000 ms: before, most of the photo; with the fix, the whole photo. At 6,389 ms: before, the whole photo; with the fix, the whole photo.beforewiththe fix1,319 msThe home page showing the wordsThe home page showing the whole photofixed: whole2,500 msThe home page showing a strip of the photoThe home page showing the whole photogood LCP line4,000 msThe home page showing most of the photoThe home page showing the whole photopoor LCP line6,389 msThe home page showing the whole photoThe home page showing the whole photobefore: whole
The home page in the lab, as it is (top) and with the fix (bottom), on the same phone and network. Each column is one moment. With the fix, the photo is whole at 1,319 ms. Before, only at 6,389 ms.
What Asha sees at 2.5 secondsPop out in the code editor (opens in a new tab)JavaScript
// Frames of the home page in the lab: when each appeared (ms), and what it showedconst before = [[4, "nothing"], [1227, "the words"], [1818, "a strip of the photo"], [6389, "the whole photo"]];const after = [[4, "nothing"], [1232, "the words"], [1250, "a blurry part of the photo"], [1319, "the whole photo"]];const at = (frames, ms) => frames.filter(([time]) => time <= ms).at(-1)[1]; console.log(`At 2.5 s, before the fix: ${at(before, 2500)}`);console.log(`At 2.5 s, with the fix: ${at(after, 2500)}`);
  • Line 2 holds four of the 8 frames of the page as it is: when each one appeared, in ms, and what it showed.
  • Line 3 holds every frame of the page with the fix.
  • Line 4 finds the frame on screen at a moment: the last one that appeared at or before it.
  • Lines 6 and 7 print At 2.5 s, before the fix: a strip of the photo and At 2.5 s, with the fix: the whole photo.

2.5 seconds is Google's line for a good LCP. At that moment, Asha sees a thin strip of the photo. With the fix, she sees all of it. Why it matters: the owner doesn't need to know what LCP means to see this.

Two habits keep a filmstrip honest. Change one thing only: if the "after" row had a faster network, it would prove nothing. And give it a caption that says what to notice. Google's writing course says a good caption explains the takeaway. Ravi's says: "With the fix, the photo is whole at 1.3 seconds instead of 6.4."

A trace shows why

Meera needs more than pictures. She needs to see the cause herself, and check it. A trace is the Performance panel's recording of a load: every request, task and paint. Ravi doesn't send her a screenshot of it. He sends the file itself, with his notes on it.

DevTools calls these notes annotations, and lesson 7.6 showed how to add them. Ravi added two. One is a label on the photo's request. The other marks the stretch of time while the photo downloads. When you save a trace, its annotations are kept unless you turn them off. Anyone who opens the file in the Performance panel sees them. Here is Ravi's trace, with his notes.

One warning from DevTools' docs. If you also save the page's files in the trace, and they hold anything private, treat the trace as private too.

Why it matters: Meera can check the cause herself, instead of taking Ravi's word for it.

A p75 shows how many

The first claim is about real visitors, so it needs field data: numbers from real visits. Ravi uses the number Google uses, the p75. Three visits in four were at it or faster. web.dev reads it for phones and computers apart. Search Console, Google's tool for site owners, has a Core Web Vitals report. It shows the same kind of number, over the last 28 days. So the owner can set Ravi's numbers beside Google's. Lesson 3.4 showed why a p75 beats an average.

Case studies show field evidence this way too. The Economic Times' study gives its p75 LCP before and after, 4.5 seconds and then 2.5. It also charts the share of good and poor visits, month by month.

Now match them up. Pick a piece of evidence, and see which of Ravi's claims it proves:

Playground: which evidence proves which claim?
What the filmstrip shows
  • Two lab loads on Asha's phone: Slow 4G, the CPU 4× slower.
  • As it is: the whole photo at 6,389 ms.
  • With the fix: the whole photo at 1,319 ms.
Ravi's three claims
  1. Many phone visitors wait too long for the home photo.Can't prove it. One lab load can't say how many real visitors wait.
  2. The photo is late because the file is too big and starts late.Can't prove it. It shows the photo arriving late, not why.
  3. With the fix, the photo appears about 5 seconds sooner.Proves it.
Try it yourself
The filmstrip proves: with the fix, the photo appears about 5 seconds sooner

The top lists what this evidence shows. Each row below is one claim from Ravi's report, and whether this evidence proves it.

From the audit's recording and this lesson's lab loads, in Chrome 157.

Each piece of evidence proves one claim, and none proves all three. Why it matters: when a reader doubts a claim, hand them the evidence for that claim, not a pile of everything.

Show what got worse, too

Honest evidence includes the bad news. Vodafone's case study has a table of its two pages. The faster page had a better LCP, but its DOMContentLoaded, the event that fires once the HTML is read, came 15% later. The study says so plainly. Ravi checked his fixed home page the same way. Its INP, how fast it answers a tap, and its CLS, how much it jumps, stayed good. His report says that too.

One finding, written for Meera and for the owner

Meera and the owner read the same report for different reasons. Google's writing course puts it as a sum. Good writing gives readers what they need to do a task, minus what they already know.

Meera knows LCP, srcset and traces. Her task is to fix the page. The owner knows the shop, its customers and its money. Her task is to decide. So one finding needs two texts.

Real-life analogyA doctor's two letters

After your knee scan, the doctor writes two letters. Yours says: "There's a small tear. Rest for two weeks, then start the exercises. We'll check again in six weeks." The letter to your physio has the scan, the measures, and the medical names. Same knee, same scan, two letters.

In real life: Your letter
In a report: The owner's part: what it means, what to do, when we check
In real life: The letter to the physio
In a report: Meera's part: the numbers, the files, the trace
In real life: The scan
In a report: The evidence both parts point to
In real life: "We'll check again in six weeks"
In a report: How we'll know it worked

The course warns about the curse of knowledge: experts forget that others don't know what they know. Ravi's list had it. Every word in it made sense to him.

Here is the home photo finding, written three ways. Pick one. The lab checks it for six parts, and lists the words the owner would ask about:

Playground: one finding, three ways
Weak

The home page is slow and its LCP is bad. We should optimize the images.

What it has
  1. What's wrong, with a number and its linemissing
  2. Who it hurts, and how manymissing
  3. Why it happensmissing
  4. How we knowmissing
  5. What to change, and what it costsmissing
  6. When it's donemissing
  7. Words the owner would have to ask about1: LCP
Try it yourself
Neither reader can act on it: 0 of 6 parts

The owner can't tell how bad it is, who it hurts, or what it costs. Meera can't tell which image, what's wrong with it, or what to change.

The home photo finding from Ravi's audit. Every number comes from the course's recording.

The weak one has none of the six parts. "LCP is bad" gives the owner a word to look up, and gives Meera nothing to do. Meera's version has all six, in her words: the element, the file, the attribute, the lab setting and the trace. The owner's version has all six too, in plain words: who waits, how long, against which line, the cost, and the day.

Read this table across: each row asks one question, and shows how each version answers it.

One finding, two readers
QuestionFor MeeraFor the owner
What's wrong?p75 LCP of 4,896 ms on phones, over 72 visits. The line is 2,500 ms.One phone visit in four waits 4.9 seconds or more for the home photo.
How do we know?The trace with notes, and the lab setting to see it for herself.Two rows of screenshots: the photo at 6.4 seconds, and at 1.3 with the fix.
Why?An 825 kB PNG, shown 380 px wide, with loading="lazy".The photo is far bigger than a phone needs, and it starts late.
What should change?JPEGs at three widths in srcset. No lazy. fetchpriority="high".Make the photo smaller, and load it first.
What does it cost?About 5 hours, and a lab check when it ships.About 5 hours of Meera's time.
What's needed from the reader?Ship it by day 5.A yes to 12 hours of work this week.

Sentences built from the numbers

Ravi writes the owner's sentences straight from the audit's numbers, so they stay true:

The home photo, in the owner's wordsPop out in the code editor (opens in a new tab)JavaScript
// The home photo, from the audit: phone visits in the field, and the lab before and with the fix (ms)const field = { p75: 4896, over: 43, visits: 72 };const lab = { before: 6388, after: 1304, hours: 5 };const seconds = (ms) => (ms / 1000).toFixed(1); console.log(`One phone visit in four waits ${seconds(field.p75)} s or more for the home photo.`);console.log(`${field.over} of ${field.visits} phone visits wait longer than Google's 2.5 s.`);console.log(`${lab.hours} hours of work: the photo came ${seconds(lab.before - lab.after)} s sooner in our tests.`);
  • Line 2 holds the home page's phone visits: the p75, how many were over the line, and how many there were.
  • Line 3 holds the lab's middle load before and with the fix, and the hours of work.
  • Line 4 turns milliseconds into seconds, with one decimal. Owners think in seconds.
  • Lines 6 to 8 print One phone visit in four waits 4.9 s or more for the home photo., 43 of 72 phone visits wait longer than Google's 2.5 s. and 5 hours of work: the photo came 5.1 s sooner in our tests.

"One visit in four" is the p75, said plainly: a quarter of visits were at it or slower. Each sentence also keeps where its number came from: real visits, or "our tests". Why it matters: the owner can repeat these sentences to anyone, and they stay true. Ravi's first note to the owner, in lesson 1.2, was built the same way: only what he measured, and what he could quote.

One chart for the owner

To decide, the owner needs the cost as well as the gain. web.dev's guide to working across a company says the same: come with an estimate of the work. Ravi gives her hours, and one chart. It shows every lab load, not just the middle ones, so she can see they don't wobble:

Ten lab loads of the home page as bars. Before the fix: 6,364 ms, 6,376 ms, 6,388 ms, 6,388 ms, 6,400 ms. With the fix: 1,292 ms, 1,292 ms, 1,304 ms, 1,316 ms, 1,324 ms. A dashed line marks Google's line for a good LCP, 2,500 ms.Google's line: 2,500 msbeforemiddle:6,388 mswith the fixmiddle:1,304 ms0 s2 s4 s6 s
Every lab load from the audit, with Slow 4G and the CPU 4× slower. All five loads before the fix are far past Google's line, and all five with the fix are well under it. On the left, the middle load of each group.

The audit loaded the two versions taking turns, so a busy moment on the computer couldn't favour either one. Lesson 39.3 drew the same line for dashboards: splits for the people who fix, a weekly trend for the people who decide.

Check that it worked, and keep it that way

A report isn't done when it's sent. Its last part says how everyone will know the fixes worked. Then Ravi has to look, and say what he found.

Real-life analogyA roof repair, then the gutters

A roofer fixes a leak. You don't trust it on a sunny day. You check the ceiling after the next big rain. If it's dry, you tell the family. Then you clear the gutters every autumn, so the water can't back up under the tiles again.

In real life: A dry ceiling on a sunny day
In follow-up: The lab, on the day the fix ships
In real life: The next big rain
In follow-up: Enough real visits after the fix
In real life: Telling the family it held
In follow-up: The follow-up note
In real life: Clearing the gutters every autumn
In follow-up: A budget and an alert that keep it fixed

Three checks, from quick to sure

  • In the lab, the day it ships. Load the page five times with the audit's setting. The middle LCP should be near the 1,304 ms the lab gave before.
  • In the field, after enough visits. Wait until the home page has had as many new phone visits as the audit used: 72. Then its p75 LCP should be under 2,500 ms. Compare like with like: the same page, the same devices, as many visits.
  • In Google's data, after 28 days. For a site with enough Chrome visitors, Search Console can watch a fixed problem for 28 days. If no page shows it in that time, it marks the problem fixed.

Lesson 13.2 showed how to tell a real change from chance, and how to report one. Did the faster pages bring more orders? That's a different question. It needs a fair test, with visitors split by chance. The next lesson runs one.

Report back

After each check, Ravi sends a short note: what was done, what changed, and what's next. Three lines are enough. This lesson's 5 loads of the fixed home page are his lab check. Here is his note on day 5:

"Done: the tea list on day 2, and the home photo today. Lab check, 5 loads with the audit's setting: the middle LCP is 1,316 ms, as the audit predicted. Next: the field check after 72 new phone visits, and the cart and the offer on day 7."

web.dev's guide goes further: put speed into the regular reports to the business, so it doesn't stay a one-off project.

Keep it fixed

The 825 kB PNG came from a design tool, saved with one click. Next month a new photo could arrive the same way. So the report's last action adds two guards from Module 39. The first is a budget, a limit the team agrees not to cross, from lesson 39.1. It's checked on every pull request, as in lesson 39.2:

A budget for the home page's photosPop out in the code editor (opens in a new tab)JavaScript
// The home page's photos in bytes, before the fix and with itconst before = { "green-tea.png": 825305 };const after = { "green-tea-412.jpg": 4695, "green-tea-800.jpg": 11484, "green-tea-1200.jpg": 23120 };const limit = Math.ceil((23120 * 1.1) / 1000) * 1000; // the biggest photo, plus a tenth const tooBig = (files) => Object.keys(files).filter((name) => files[name] > limit);console.log(`Budget: ${limit / 1000} kB per photo`);console.log(`Before: ${tooBig(before).join(", ") || "every photo within budget"}`);console.log(`With the fix: ${tooBig(after).join(", ") || "every photo within budget"}`);
  • Lines 2 and 3 hold the photos' sizes in bytes: the PNG before, and the three JPEGs with the fix.
  • Line 4 sets the budget with lesson 39.1's rule: the biggest photo today, plus a tenth, rounded up to a whole kB.
  • Line 6 keeps every file over the budget.
  • Lines 7 to 9 print Budget: 26 kB per photo, Before: green-tea.png and With the fix: every photo within budget.

The budget would have failed the build on the day the PNG went in. Why it matters: the fix stays fixed, even when nobody remembers the audit.

The second guard is an alert on real visits, from lesson 39.3. Ravi sets one on the home page's p75 LCP on phones, at 2,500 ms. That lesson's rules apply: skip hours with too few visits, and wait for a lasting change before sending a message.

Which part of the report?

Each line below comes from Ravi's report. Sort it into the part it belongs in:

Which part of the report?
  • A third of our visits meet a slow or jumpy page
  • We need a yes for 12 hours of work this week
  • Screenshots of the home photo at 6.4 s, and at 1.3 s with the fix
  • The home trace with notes on the photo's request
  • Day 2, Meera: show the teas, then rank them
  • Not now: rank the teas on the server, 24 hours, same visits as day 2's fix
  • After 72 new phone visits, the home page's p75 LCP is under 2,500 ms
  • A build check: no home photo over 26 kB
Try it yourself
0 of 8 correct

Sort each line by the part of the report it belongs in.

Choose a category for every card. You can change an answer at any time; Reset clears them all.

Common mix-ups

  • "A good audit speaks for itself." No. Ravi's list held the right fixes, and nobody acted on it for a week.
  • "Start the report with how you did the audit." No. Readers may stop after a few lines. Put the answer first, and the method last.
  • "More evidence makes a stronger report." No. Each claim needs the one piece of evidence that answers it. A pile hides it.
  • "A screenshot of the trace is enough for the engineer." No. Send the trace file with notes, so she can check the cause herself.
  • "The manager's version is the engineer's with the details cut." No. It needs different things: what visitors feel, how many, the cost in hours, and a decision.
  • "A better lab number proves the fix worked." No. The lab predicts. Real visits decide, once there are enough of them.
  • "Once it's fixed, it stays fixed." No. The big PNG arrived with one click. A budget and an alert catch the next one.

Practice exercises

Answer first, then use the hints.

Exercise 1 · Warm-upA later cart

Meera can't do the cart until day 9, and Ravi takes the offer. What does the third line print?

Starter codePop out in the code editor (opens in a new tab)JavaScript
// Meera can't do the cart until day 9, and Ravi takes the offer
const actions = [
  { what: "Tea list: show the teas, then rank them", who: "Meera", day: 2 },
  { what: "Home: smaller photo, loaded first", who: "Meera", day: 5 },
  { what: "Cart: show the count, then the total", who: "Meera", day: 9 },
  { what: "Reviews: put the offer in the HTML", who: "Ravi", day: 7 },
];
for (const { what, who, day } of actions) {
  console.log(who ? `Day ${day}, ${who}: ${what}` : `No owner yet: ${what}`);
}

Answer, then press Check. Spacing and letter case don’t matter.

    Exercise 2 · Warm-upA bigger photo

    Meera adds a 2,400 px photo for big screens. Its size here is made up: 61,830 bytes. What does the last line print?

    Starter codePop out in the code editor (opens in a new tab)JavaScript
    // The home page's photos in bytes, before the fix and with it
    const before = { "green-tea.png": 825305 };
    const after = { "green-tea-412.jpg": 4695, "green-tea-800.jpg": 11484, "green-tea-1200.jpg": 23120, "green-tea-2400.jpg": 61830 };
    const limit = Math.ceil((23120 * 1.1) / 1000) * 1000; // the biggest photo, plus a tenth
    
    const tooBig = (files) => Object.keys(files).filter((name) => files[name] > limit);
    console.log(`Budget: ${limit / 1000} kB per photo`);
    console.log(`Before: ${tooBig(before).join(", ") || "every photo within budget"}`);
    console.log(`With the fix: ${tooBig(after).join(", ") || "every photo within budget"}`);

    Answer, then press Check. Spacing and letter case don’t matter.

      Exercise 3 · PracticeWhat the trace says

      In the evidence playground, pick the trace with notes. How many bytes does it say the photo could lose?

      Answer, then press Check. Spacing and letter case don’t matter.

        Exercise 4 · PracticeWords to look up

        In the playground with three versions, pick Meera's. How many words would the owner have to ask about?

        Answer, then press Check. Spacing and letter case don’t matter.

          Exercise 5 · ChallengeRavi's label

          Open Ravi's trace with notes in DevTools' Performance panel. What is the second sentence of his label on the photo's request?

          Answer, then press Check. Spacing and letter case don’t matter.

            Exercise 6 · ChallengeGoogle's 28-day check

            In Search Console's Core Web Vitals report, which button starts the 28-day watch of a problem you think is fixed?

            Answer, then press Check. Spacing and letter case don’t matter.

              Check your understanding

              For each question, ask: who is reading, and what do they need to act?

              The audit report quiz · 7 questionsScore: first tries count
              1. Question 1 of 7Ravi's list of six fixes was right, but nobody acted on it for a week. Why?

                Choose an answer to see the explanation.

              2. Question 2 of 7Why does the summary go before the findings, even though Ravi found things in the other order?

                Choose an answer to see the explanation.

              3. Question 3 of 7What does this made-up filmstrip code print?

                Read the code, then predictPop out in the code editor (opens in a new tab)JavaScript
                // Two made-up filmstrips: when each frame appeared (ms), and what it showed
                const before = [[0, "nothing"], [900, "the words"], [3100, "the whole photo"]];
                const after = [[0, "nothing"], [900, "the words"], [1700, "the whole photo"]];
                const at = (frames, ms) => frames.filter(([time]) => time <= ms).at(-1)[1];
                
                console.log(`At 2.5 s: ${at(before, 2500)}, then ${at(after, 2500)}`);

                Choose an answer to see the explanation.

              4. Question 4 of 7The owner asks: "How do you know the fix will make the photo come sooner?" What should Ravi show her?

                Choose an answer to see the explanation.

              5. Question 5 of 7Why does Ravi send Meera the trace file instead of a screenshot of it?

                Choose an answer to see the explanation.

              6. Question 6 of 7One action reads "Meera: make the home page faster." What's wrong with it?

                Choose an answer to see the explanation.

              7. Question 7 of 7The fixed home page loads in 1.3 s in the lab. Is Ravi's job done?

                Choose an answer to see the explanation.

              Key takeaways

              • A list of fixes isn't a report. A report is the audit written for the people who must act on it.
              • Put the answer first: what's wrong, what to do, what it costs, and what you need. Readers may stop after a few lines.
              • Every claim needs its own evidence: a p75 for how many, a trace for why, and a before-and-after filmstrip for what visitors will see.
              • Write each finding for its reader. Meera needs files, attributes and the trace. The owner needs seconds, visitors, hours and a decision.
              • Every action gets a name and a day after the report. A "not now" gets its reason.
              • Follow up: the lab on the day it ships, the field after as many visits as the audit, then a short note. A budget and an alert keep it fixed.

              Remember the one-liner.
              Answer first, prove each claim, put a name and a day on every fix, and check that it worked.

              Sources

              The facts on this page come from these docs:

              Coming next: Performance experiments. You'll test whether a faster page really brings more orders.

              CompleteFrontend Clear concepts. Working examples.