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.
- 01Put 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.
- 02Prove 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.
- 03Write 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 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.5down to6. 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:
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
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.
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:
# 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:
- A third of our visits meet a slow or jumpy page: 106 of 320, almost all on phones.
- I collected 320 visits to our five pages, on phones and computers.
- How bad is it?answer first: line 1; Ravi's order: not yet
- What will it cost?answer first: not yet; Ravi's order: not yet
- What do you need from me?answer first: not yet; Ravi's order: not yet
The owner has three questions. Each row says which line answers it in each version: the answer first, then the order Ravi worked in.
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: 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 themandDay 5, Meera: Home: smaller photo, loaded first. - Then come
Day 7, Meera: Cart: show the count, then the totalandNo 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?
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:
// 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 photoandAt 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:
- 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.
- 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.
- 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.
- With the fix, the photo appears about 5 seconds sooner.Proves it.
The top lists what this evidence shows. Each row below is one claim from Ravi's report, and whether this evidence proves it.
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.
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:
The home page is slow and its LCP is bad. We should optimize the images.
- What's wrong, with a number and its linemissing
- Who it hurts, and how manymissing
- Why it happensmissing
- How we knowmissing
- What to change, and what it costsmissing
- When it's donemissing
- Words the owner would have to ask about1: LCP
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 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.
| Question | For Meera | For 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, 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.and5 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:
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.
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:
// 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.pngandWith 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:
- 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
Sort each line by the part of the report it belongs in.
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.
Meera can't do the cart until day 9, and Ravi takes the offer. What does the third line print?
// 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}`);
}Day 9, Meera: Cart: show the count, then the total. Every action has a name now, so no line prints a warning.
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?
// 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"}`);With the fix: green-tea-2400.jpg. The new photo breaks the budget, so the build would fail before it reaches anyone.
In the evidence playground, pick the trace with notes. How many bytes does it say the photo could lose?
809,256 bytes. Nearly all of the 825 kB PNG could go. That's evidence for why the photo is late, not for how many visits wait.
In the playground with three versions, pick Meera's. How many words would the owner have to ask about?
13. Every one of them is right for Meera, and every one would stop the owner. That's why she gets her own version.
Open Ravi's trace with notes in DevTools' Performance panel. What is the second sentence of his label on the photo's request?
Lazy, so it starts late. The first sentence gives the size; the second gives the reason the photo's request starts late.
In Search Console's Core Web Vitals report, which button starts the 28-day watch of a problem you think is fixed?
Start Tracking, on the problem's details page. It starts a 28-day watch of CrUX data. It doesn't make Google look at the site again.
Check your understanding
For each question, ask: who is reading, and what do they need to act?
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.
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.
Question 3 of 7What does this made-up filmstrip code print?
Read the code, then predict// 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.
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.
Question 5 of 7Why does Ravi send Meera the trace file instead of a screenshot of it?
Choose an answer to see the explanation.
Question 6 of 7One action reads "Meera: make the home page faster." What's wrong with it?
Choose an answer to see the explanation.
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:
- Technical Writing One: Documents, Google for Developers.
- Vodafone: A 31% improvement in LCP increased sales by 8%, web.dev.
- Why does speed matter?, web.dev, Learn Performance.
- Technical Writing Two: Illustrating, Google for Developers.
- Annotate and share your performance findings, Chrome DevTools docs.
- Save and share performance traces, Chrome DevTools docs.
- Web Vitals, web.dev.
- Core Web Vitals report, Search Console Help.
- How The Economic Times passed Core Web Vitals thresholds and achieved an overall 43% better bounce rate, web.dev.
- Technical Writing One: Audience, Google for Developers.
- Fixing website speed cross-functionally, web.dev.
Coming next: Performance experiments. You'll test whether a faster page really brings more orders.