Building a performance culture
How a team keeps a site fast after the big fix: who owns speed, what a performance champion does, goals as service levels with error budgets, and celebrating wins.
- 01Say who owns speedEveryone owns the speed of their own change. One person owns the goal. A champion owns the tools and the teaching.
- 02Write a goal as a service levelTurn "keep it fast" into an SLI, an SLO and a window, with an error budget, a burn rate and a written policy.
- 03Keep the habit goingPut the numbers where people work, report them every week, and celebrate each win with a name and numbers.
Fast today. Still fast next month?
The owner of the Leaf and Kettle reads Ravi's answer to the agency from lesson 41.2. She's pleased. The home page is fast now, and the Mint tea page passes Google's lines. Then she asks one more question: "How do we keep it this way?"
It's a fair worry. Pages don't stay fast on their own. Ravi looks back over the last few weeks. Three changes slowed the shop's pages, and he made none of them:
// Three slowdowns at the Leaf and Kettle, from lessons 39.1, 39.3 and 40.1const slowdowns = [ { change: "Ben's carousel", cost: "14.6 times the JavaScript", foundBy: "the size check", beforeVisitors: true }, { change: "Meera's pop-up", cost: "phone p75 LCP from 640 to 1360 ms", foundBy: "the RUM alert", beforeVisitors: false }, { change: "the 825 kB home photo", cost: "phone p75 LCP of 4896 ms", foundBy: "Asha's message", beforeVisitors: false },]; const early = slowdowns.filter((slowdown) => slowdown.beforeVisitors);console.log(`${early.length} of ${slowdowns.length} were caught before visitors saw them`);for (const slowdown of slowdowns) console.log(`${slowdown.change}: found by ${slowdown.foundBy}`);- Line 1 is a comment. Each slowdown comes from an earlier lesson.
- Lines 3 to 5 hold one slowdown each: the change, what it cost, and what found it. LCP, Largest Contentful Paint, is when the biggest image or text appears. The p75 is the visit three quarters of the way up: three visits in four were at or under it.
- Line 8 keeps the slowdowns that were caught before any visitor saw them.
- Line 9 prints
1 of 3 were caught before visitors saw them. Line 10 prints one line for each slowdown, such asMeera's pop-up: found by the RUM alert.
Only Ben's carousel was stopped in time. The size check from lesson 39.2 runs on every pull request, and his change was one. Meera's pop-up came through the tag manager, so no check ran. The big photo was saved from a design tool, before the shop had any check for photos. Here is what Asha's phone showed after each change:
Ben's page looked the same, but it carried 14.6 times the JavaScript. Meera's pop-up covered the bottom of the screen with a bigger photo. The old home photo was still coming in after 2.8 seconds. Why it matters: each slowdown came from someone doing their normal job, through a different door. Ravi can't guard every door alone.
You dig a new garden in spring. It looks perfect. But weeds blow in every week, from everywhere. The garden stays tidy only when everyone who walks through pulls the weeds they see. One gardener keeps the tools sharp and says which plants matter most.
- In real life: The big dig in spring
- In a performance culture: The big fix: Ravi's audit and Meera's new photo
- In real life: Weeds blown in every week
- In a performance culture: Small slowdowns from every change: code, tags and photos
- In real life: Everyone pulling the weeds they pass
- In a performance culture: Each person checking the speed of their own change
- In real life: The gardener's plan and sharp tools
- In a performance culture: A goal everyone agreed, and a champion's checks
A performance culture is the habits that keep a site fast after the big fix. Everyone who changes the page owns the speed of their change. One person owns the goal. A champion makes the numbers easy to see, and the team celebrates every win. Fixes make a page fast. Habits keep it fast.
The rest of the lesson builds those habits at the Leaf and Kettle, one at a time:
- Who owns performance: who owns each change, and who owns the goal.
- Goals and service levels: a goal with a number, and a budget for slow visits.
- Performance champions: what Ravi does, and what he leaves to others.
- Celebrating wins: how to say thank you, with numbers.
Where the numbers come from
- The week: lesson 39.3's week of visits to the Mint tea page, made in Chrome 157. It has 1,120 phone visits, 160 a day. Each one sent its own numbers home. Meera's pop-up went live on Thursday at 10:20.
- Ben's carousel: lesson 39.1's loads on Asha's phone in the lab. That's Chrome with a phone's screen, a slow network and a CPU four times slower.
- The home photo: lesson 40.1's field data from before the fix, and lesson 40.3's test week of Meera's new photo.
Every sum in this lesson runs on those recorded visits, and the lesson's test checks each one.
Everyone changes the speed, one person owns the goal
So whose job is speed? Many teams answer "the developers". web.dev's guide on fixing speed across a company calls that "one common myth". It says "a fast site requires help from several departments". Developers alone "can rarely solve the issues".
The Leaf and Kettle shows why. Look at who changes its pages:
- Ben writes code. His changes go through pull requests, where the checks from lessons 39.1 and 39.2 run.
- Meera plans what goes on each page. She adds photos, and she adds scripts through the tag manager, with no pull request.
- The owner decides what the shop builds next, and where everyone's hours go.
Bigger shops find the same thing. Farfetch, a large fashion shop, wrote about it on web.dev. Speed there was "mostly seen as the responsibility of the engineering teams". So it became "invisible to other areas of the business". Farfetch set out to make speed "a shared responsibility". It built a core team from engineering, infrastructure, architecture and product. One of its product managers put the aim plainly. They wanted to stop speed being "something owned only by the engineering team to deal with and fix".
In a café kitchen, every cook washes their hands and labels what goes in the fridge. Nobody waits for the manager to do it. But one person, the manager, signs the hygiene record. She decides when the kitchen closes early for a deep clean.
- In real life: Each cook washing their hands
- In a performance culture: Each person checking the speed of their own change
- In real life: The manager who signs the hygiene record
- In a performance culture: The owner, who owns the goal
- In real life: Closing early for a deep clean
- In a performance culture: Pausing new work when speed slips too far
So everyone owns their own change. But someone has to own the goal too. Google's Site Reliability Workbook says who. A goal like this "needs to be owned by someone in the organization who is empowered to make tradeoffs" between new features and reliability. "In a small organization, this may be the CTO": the person in charge of the company's technology. In bigger ones, it's usually the product manager.
At the Leaf and Kettle, that's the owner. She decides where the hours go, so only she can say "the fix comes before the new feature". Read this table across: each person, what they own, and the check that helps them.
| Who | What they own | The check that helps them |
|---|---|---|
| The owner | The goal, and what happens when it's missed. She decides what comes first. | A short weekly note: one number, its trend and its cause. |
| Ravi, the champion | The checks, the dashboards and the teaching. | Everyone checking their own change, so he isn't cleaning up after them. |
| Ben, who writes code | The speed of his own pull requests. | The size check and Lighthouse CI on every pull request, from lessons 39.1 and 39.2. |
| Meera, who plans the pages | The speed of her photos and her tags. | The live alert from lesson 39.3, and Ravi's speed bar while she previews. |
Why it matters: when everyone owns their change, slowdowns get caught at every door. When one person owns the goal, someone can say "fix this first", and it sticks.
A goal with a number: service levels
"Keep it fast" isn't a goal anyone can check. Fast for whom? On which page? How often? The owner needs a goal with a number in it. Ravi borrows three terms from Google's book Site Reliability Engineering:
- A service level indicator, or SLI, is a number that measures how good the service is. The book calls it "a carefully defined quantitative measure".
- A service level objective, or SLO, is "a target value" for an SLI. It's the goal.
- A service level agreement, or SLA, is a promise to users with "consequences" when it's missed, like a refund. Think of a pizza shop that says "in 30 minutes, or it's free". With no consequence, it's an SLO.
Google's line is already a service level
You've met one SLO already. web.dev calls an LCP good at 2.5 seconds or less, measured at the p75. A p75 within the line means at least three visits in four are within it. So the same rule can be said as a share: at least 75% of visits within 2,500 ms. Here is Friday of lesson 39.3's week, both ways:
// Friday's phone visits to the Mint tea page (lesson 39.3)const visits = 160;const p75 = 1360;const within = { 2500: 154, 1000: 98 }; for (const line of [2500, 1000]) { const share = within[line] / visits; console.log(`${line} ms: p75 ${p75 <= line ? "within" : "over"}, ${(share * 100).toFixed(1)}% of visits within`);}- Lines 2 and 3 hold Friday's recorded phone visits and their p75.
- Line 4 holds how many of those visits were within each line.
- Lines 6 to 9 check each line both ways. They print
2500 ms: p75 within, 96.3% of visits withinand1000 ms: p75 over, 61.3% of visits within.
At 2,500 ms, the p75 is within, and well over 75% of visits are within. At 1,000 ms, both fail together. They always agree. Why it matters: a share of good visits is easy to count, add up and explain. The SRE workbook recommends exactly this shape: "the number of good events divided by the total number of events".
The shop's own goal
Google's line passed every day of that week. Yet on phones, the p75 more than doubled after Meera's pop-up. A line that far away can't see a change like that. The SRE book suggests keeping "a safety margin": an inside goal that's tighter than the outside one. It gives you room to act before a problem shows outside.
So the owner writes the goal from what she wants for her visitors. On phones, she wants the tea photo within a second, nearly every time. Ravi checks that it's possible. From Monday to Wednesday, before the pop-up, 93.1% of phone visits made it. They agree on this:
"9 in 10 phone visits to the Mint tea page show their LCP within 1,000 ms, counted over the last four weeks, from our own RUM."
RUM, real user monitoring, means each real visit sends its numbers home. Each part of the goal does a job:
- "Phone visits to the Mint tea page" says what's counted.
- "Within 1,000 ms" makes each visit good or slow. The share of good visits is the SLI.
- "9 in 10" is the SLO.
- "The last four weeks" is the window. The workbook calls a rolling four weeks "a good general-purpose interval", with a summary each week.
Here is the week from lesson 39.3, one day at a time:
// Phone visits to the Mint tea page each day, and how many had an LCP within 1,000 ms (lesson 39.3)const days = { Mon: [160, 152], Tue: [160, 146], Wed: [160, 149], Thu: [160, 117], Fri: [160, 98], Sat: [160, 95], Sun: [160, 99] };const goal = 0.9; for (const [day, [visits, good]] of Object.entries(days)) { const sli = good / visits; console.log(`${day}: ${(sli * 100).toFixed(1)}% ${sli >= goal ? "met" : "missed"}`);}- Line 2 holds each day's recorded phone visits, and how many had an LCP within 1,000 ms.
- Line 3 is the goal: 9 in 10, written as 0.9.
- Line 6 divides the good visits by all the visits. That share is the day's SLI.
- Line 7 prints one line a day, from
Mon: 95.0% mettoSun: 61.9% missed.
Monday to Wednesday met the goal. From Thursday, every day missed it. Here is each day's count of slow visits, against the 16 a day the goal allows:
Why it matters: the goal turns "the page feels slower" into a count anyone can check. And it caught what Google's line missed. Slide the line to see what each choice would have caught:
- Mon95.0% within: met
- Tue91.3% within: met
- Wed93.1% within: met
- Thu73.1% within: missed
- Fri61.3% within: missed
- Sat59.4% within: missed
- Sun61.9% within: missed
- The whole week76.4% within: missed
Each row is the share of that day's phone visits with an LCP within the line. The goal is 90% within it. Google's line for a good LCP is 2,500 ms.
A budget for slow visits
The goal doesn't ask for every visit to be fast. That's on purpose. The SRE book says insisting on 100% is "both unrealistic and undesirable". It would slow down new work. So the 1 visit in 10 that may be slow is a budget to spend. It's called the error budget: 100% minus the SLO.
Your phone plan gives you 10 GB of data a month. You can spend it how you like: maps, music, a film on the train. Watch a film every evening, though, and the month's data is gone in a week. Then the films stop until the new month starts.
- In real life: The 10 GB a month
- In a performance culture: The error budget: 1 slow visit in 10, over four weeks
- In real life: A film on the train
- In a performance culture: A new feature or tag that costs a little speed
- In real life: Using data faster than the month allows
- In a performance culture: A burn rate above 1
- In real life: No more films until the new month
- In a performance culture: No new changes until the goal is met again
How fast is the budget going? The SRE workbook calls that the burn rate: "how fast, relative to the SLO, the service consumes the error budget". A burn rate of 1 spends the budget exactly over the window. A burn rate of 2 spends it in half the time. Here is the week, split at Thursday 10:20:
// Phone visits before and after Meera's tag went live, Thursday 10:20 (lesson 39.3)const before = { visits: 526, slow: 35 };const after = { visits: 594, slow: 229 };const budget = 1 - 0.9; // the goal lets 1 visit in 10 be slow for (const [when, part] of Object.entries({ before, after })) { const burn = part.slow / part.visits / budget; console.log(`${when}: burn rate ${burn.toFixed(2)}, four weeks of budget last ${(28 / burn).toFixed(1)} days`);}- Lines 2 and 3 hold the recorded phone visits before and after the pop-up, and how many were slower than 1,000 ms.
- Line 4 is the budget: 1 minus 0.9 is 0.1, one visit in ten.
- Line 7 divides the share of slow visits by the budget. That's the burn rate.
- Line 8 prints
before: burn rate 0.67, four weeks of budget last 42.1 daysandafter: burn rate 3.86, four weeks of budget last 7.3 days.
Before the pop-up, the shop spent its budget more slowly than allowed. There was room for new work. After it, the budget burned 3.9 times too fast. At that pace, four weeks of budget are gone in about a week. Why it matters: the alert from lesson 39.3 said something changed. The burn rate says how much it matters. Pick a day to see its pace:
- Phone visits160
- Slower than 1,000 ms8
- Slow visits the goal allows16
- Burn rate0.50
- Four weeks of budget would last56.0 days
The burn rate is the share of slow visits divided by the budget, 1 in 10. At 1, four weeks of budget last exactly 28 days. Above 1, they run out sooner.
What happens when the budget runs out
A budget needs a rule for when it's spent. The workbook calls it an error budget policy: written down and agreed before anything goes wrong. Its example policy stops "all changes and releases" until the service is back within its SLO. Only top-priority bugs and security fixes still go out. It also says what the policy isn't: "This policy is not intended to serve as a punishment for missing SLOs."
The Leaf and Kettle's policy fits on a card:
- While there's budget left, everyone ships as usual.
- When the four-week budget is spent, no new features or tags go on that page. Fixing speed comes first.
- When one change spends a big part of the budget, the team looks at it together and writes down what it learned.
- If the team disagrees about any of this, the owner decides.
The workbook also says who must agree. The product side agrees the line is good enough for users. The people who build agree to take fewer risks when the budget is spent. The people who defend the goal agree they can meet it "without Herculean effort". At the Leaf and Kettle, that's the owner, Ben and Meera, and Ravi. Why it matters: when the budget runs out, nobody argues about what to do. They agreed already.
A champion makes speed everyone's habit
Someone still has to build the checks, read the numbers and teach the rest. That's a performance champion: a person who cares about speed and helps everyone else care too. At the Leaf and Kettle, it's Ravi.
There's a trap. Lara Callender Hogan managed the performance team at Etsy. In her book Designing for Performance, she describes how one person often becomes the "performance cop" or "janitor". They clean up after everyone else's changes. She warns that "this road leads to burnout." There should be champions, she says. But leaving speed to "a small group of people" makes it nearly impossible to keep.
An office has a fire warden on each floor. The warden doesn't fight every fire alone. They show new staff the exits, check the extinguishers and run the drills. When the alarm rings, everyone already knows what to do.
- In real life: Showing new staff the exits
- In a performance culture: Teaching the team what slows pages down
- In real life: Checking the extinguishers
- In a performance culture: Keeping the checks and dashboards working
- In real life: Running the drills
- In a performance culture: Reading the weekly numbers together
- In real life: Everyone knowing what to do
- In a performance culture: Each person checking their own change
Hogan lists what a champion, or a small team of them, can do instead of cleaning up:
- Teach, with talks, lunch-and-learns and workshops.
- Build tools that put speed numbers into everyone's daily work.
- Set baselines, like a performance budget for each new project.
- Share the numbers openly, the good ones and the embarrassing ones.
- Celebrate the good work of people on other teams.
T-Mobile's case study on web.dev shows the same list at a big company. Its dashboards of real-visit numbers are open to everyone there. They show the p75 LCP, its daily trend, and the share of good, needs-improvement and poor visits. A wiki explains how to read them. Its product and SEO manager runs "web performance roadshows" to teach other teams. Alerts email the people who need to know. And pages must reach set Lighthouse levels before they launch.
Numbers where people work
Ravi has built many of these tools already. The budgets came in lesson 39.1, and the checks on every pull request in lesson 39.2. The dashboards and alerts came in lesson 39.3, and the report in lesson 40.2. But Meera never opens a dashboard while she works. So Ravi puts the number where she is.
Etsy did this with a toolbar. When its staff were signed in, the toolbar showed each page's timing data. It also showed "an alert whenever the performance times violate" the site's agreed limits. Ravi's version is one small script, added only for signed-in staff:
// speed-bar.js: Ravi adds it to pages only for signed-in staffconst goal = 1000;new PerformanceObserver((list) => { const lcp = Math.round(list.getEntries().at(-1).startTime); const verdict = lcp <= goal ? "within" : "over"; document.querySelector("#speed-bar").textContent = `LCP ${lcp} ms: ${verdict} the ${goal} ms goal`;}).observe({ type: "largest-contentful-paint", buffered: true });- Line 2 is the goal's line, 1,000 ms.
- Line 3 makes a PerformanceObserver: the browser calls its function each time it records an entry of the kind it watches.
- Line 4 takes the last LCP entry, the biggest thing painted so far, and rounds its time.
- Line 5 compares it with the goal.
- Line 6 writes the result into the bar at the top of the page.
- Line 7 starts watching LCP entries.
buffered: truealso hands over the ones recorded before the script ran.
Now Meera sees the bar while she previews a new tag or photo. She doesn't need Ravi to tell her. Here is the same observer, running on this page in your browser:
- StatusWaiting for an entry
The bar runs the same observer as Ravi's script, on this lesson's page, in your browser. Your number depends on your device and network. Move the goal to see the verdict change.
Why it matters: a number people see while they work changes what they do. A dashboard nobody opens changes nothing.
A note every week
The owner doesn't need a dashboard either. She needs a few lines she reads every week. web.dev's guide puts it plainly: "what's not reported will not be focused on." Here is Ravi's note for the week of the pop-up:
"Mint tea, phones: 76.4% of visits within 1 s this week. Goal: 90%. Missed, from Thursday 10:20. Cause: the newsletter pop-up, for new visitors. Burn rate since then: 3.9. Next: Meera and I look at the pop-up together on Monday."
One number, the goal, the cause and the next step. She can read it in a minute. Why it matters: speed that shows up in the weekly report gets time. Speed that doesn't, slips.
Celebrate wins, and name who made them
Most of this lesson has been about slowdowns. But the shop also had a big win. In lesson 40.3, Meera built the fixed home photo: smaller, and loaded first. Here is the home page on Asha's phone at 1.3 seconds, with the old photo and with Meera's:
At that moment, the old page showed only the words. Meera's showed the whole photo. The old one was whole only at 6.4 seconds. Ravi doesn't keep that to himself.
Hogan writes that "championing and celebrating performance wins is often way more successful in the long run" than going on about what went wrong. At Etsy, the performance team kept a dashboard of "performance heroes": people on other teams who made the site faster. Each one got their photo, a graph of the change and a short description. Then an email went out, so everyone could say well done.
A café keeps a thank-you board in the staff room. When someone finds a quicker way to brew the morning tea, a card goes up. It has their name, what they changed and how many minutes it saved. Everyone walks past the board. Soon, others try the same trick.
- In real life: The name on the card
- In a performance culture: Credit for the person who made the change
- In real life: How many minutes it saved
- In a performance culture: The numbers before and after
- In real life: A board everyone walks past
- In a performance culture: A note to the whole team
- In real life: Others trying the same trick
- In a performance culture: The fix spreading to other pages
Ravi writes the card with numbers from lesson 40.3's test week. He measures the win with the goal's own line, 1,000 ms:
// Lesson 40.3's test week: phone visits to the home page, with the old photo and with Meera'sconst before = { visits: 302, within1s: 13, clicked: 101 };const after = { visits: 268, within1s: 252, clicked: 128 };const share = (part, all) => `${Math.round((part / all) * 100)}%`; console.log(`Within the 1-second line: ${share(before.within1s, before.visits)} to ${share(after.within1s, after.visits)}`);console.log(`Clicked "See all our teas": ${share(before.clicked, before.visits)} to ${share(after.clicked, after.visits)}`);console.log("Built by Meera. Thank you, Meera!");- Lines 2 and 3 are recorded. They hold the phone visits to the home page with each photo. They also hold how many were within 1,000 ms, and how many clicked "See all our teas".
- Line 4 turns a part of a whole into a percentage.
- Lines 6 to 8 print
Within the 1-second line: 4% to 94%,Clicked "See all our teas": 33% to 48%andBuilt by Meera. Thank you, Meera!.
The note uses the goal's own line, so everyone reads it the same way. Ravi adds one line for the owner: lesson 41.1 priced the fix at about £930 of tea orders a month. And the note names Meera.
That's the same Meera whose pop-up spent the Mint tea page's budget. A team that blames would remember only the pop-up. A team that credits remembers both. Then Meera keeps making changes, and keeps checking them.
web.dev's guide ends on the same idea. When the numbers show a gain, share them. They reward "your team as well as all of the departments that collaborated with you". Put them in the weekly report, "so the project doesn't become a one-off effort". Why it matters: Hogan calls publishing and celebrating a win "a huge incentive". It encourages others to make the next one.
Whose job is it?
Each card is a job from this lesson. Sort it to the person who owns it at the Leaf and Kettle.
- Pick the goal: 9 phone visits in 10 within 1 s.
- Decide what comes first when the budget is spent.
- Build the speed bar and the dashboards.
- Run a lunchtime talk on how tags slow pages down.
- Post the win, with Meera's name on it.
- Check a new tag's cost before publishing it.
- Keep a pull request within the JavaScript budget.
- Save photos at the size the page shows them.
- Fix the slowdown their own change caused.
Sort each job to the person who owns it.
Ravi's answer to the owner fits in four lines. Everyone checks their own change. She owns the goal and its budget. He builds the tools and teaches. And every win gets a name.
Common mix-ups
- "Speed is the developers' job." No. web.dev calls that a common myth. Meera's pop-up never went near the code, and it more than doubled the phone p75.
- "A performance champion fixes every slowdown." No. That's the cop or janitor Lara Hogan warns about, and it leads to burnout. A champion teaches, builds tools and celebrates. Each person fixes their own change.
- "The goal should be 100% of visits fast." No. The SRE book calls that unrealistic and undesirable. Leave a budget to spend on change.
- "Google's good line is a fine team goal." No. In lesson 39.3's week, it passed every day while the phone p75 more than doubled. Keep an inside goal with a safety margin.
- "An error budget punishes whoever spent it." No. Google's example policy says it's "not intended to serve as a punishment". It gives the team permission to put speed first.
- "An SLO and an SLA are the same thing." No. An SLA has a consequence for users, like a refund. Without one, it's an SLO.
- "Celebrating wins is just being nice." No. Hogan writes that it's often more successful in the long run than repeating what went wrong. A named win shows everyone what to copy.
Practice exercises
Answer first, then use the hints.
On a quiet Monday, 9 of 120 phone visits were slower than 1,000 ms. What does the program print?
// A quiet Monday: 120 phone visits, 9 of them slower than 1,000 ms
const visits = 120;
const slow = 9;
const sli = (visits - slow) / visits;
console.log(`${(sli * 100).toFixed(1)}% within 1 s: goal ${sli >= 0.9 ? "met" : "missed"}`);92.5% within 1 s: goal met. 111 of 120 visits were within the line. That's more than 9 in 10, so the day met the goal.
Four weeks bring 4,000 phone visits. How many slow visits does the goal allow?
// Four weeks of phone visits to the Mint tea page
const visits = 4000;
const goal = 0.9;
console.log(`Budget: ${Math.round(visits * (1 - goal))} slow visits`);Budget: 400 slow visits. The goal lets 1 visit in 10 be slow. Math.round tidies the tiny rounding error in 1 - 0.9, which isn't exactly 0.1 in JavaScript.
If the goal's line were Google's 2,500 ms, what share of the whole week's phone visits would be within it?
97.6%. Even after the pop-up, almost every phone visit stayed within 2,500 ms. A goal on that line would have stayed quiet.
At Saturday's pace, how many days would four weeks of budget last?
About 6.9 days. Saturday had 65 slow visits of 160, a burn rate of about 4.06. 28 days divided by 4.06 is 6.9.
Google's example error budget policy asks for a postmortem when one incident spends more than a set share of the four-week budget. What share?
20%. If one incident uses more than a fifth of the four-week budget, the team must write a postmortem, a written review of what happened, with at least one top-priority action.
Open Thursday's Mint tea page from lesson 39.3. In DevTools' Network panel, reload, right-click popup.js and choose Block request. Reload again. What does the Status column show for popup.js?
(blocked:devtools). DevTools stopped the request, so the pop-up never appears. That's how Meera can see her page without a tag before she publishes it. Closing DevTools turns the block off.
Check your understanding
For each question, ask: is this about who owns speed, about the goal and its budget, or about keeping the habit going?
Question 1 of 7Which of these comes with a consequence, like a refund, when it's missed?
Choose an answer to see the explanation.
Question 2 of 7A team's goal is 95% of phone visits within 1,000 ms over four weeks. What is its error budget?
Choose an answer to see the explanation.
Question 3 of 7How many days does this four-week budget last?
Read the code, then predictconst goal = 0.95; const slowShare = 0.1; const burn = slowShare / (1 - goal); console.log(`${Math.round(28 / burn)} days`);Choose an answer to see the explanation.
Question 4 of 7At the Leaf and Kettle, who owns the speed goal and decides when speed work comes first?
Choose an answer to see the explanation.
Question 5 of 7Ravi spends his weeks fixing everyone else's slow changes. What does Lara Hogan warn this leads to?
Choose an answer to see the explanation.
Question 6 of 7In lesson 39.3's week, why didn't a goal set at Google's 2,500 ms line catch Meera's pop-up?
Choose an answer to see the explanation.
Question 7 of 7Which thank-you does most for the team's habits?
Choose an answer to see the explanation.
Key takeaways
- Every change can slow a page: code, tags and photos. Everyone owns the speed of their own change.
- One person owns the goal and decides when speed comes first. In a small shop, that's the owner.
- Write the goal as a service level: an SLI (the share of good visits), an SLO (the target) and a window.
- Keep the goal tighter than Google's line, so it sees a change before visitors and Google do.
- The error budget is the slow visits the goal allows. The burn rate says how fast it's going. A written policy says what happens when it's spent.
- A champion teaches, builds tools and shares the numbers. They don't clean up after everyone.
- Celebrate wins with a name and numbers. It encourages others to make the next one.
Remember the one-liner.
Everyone owns their change, one person owns the goal, a champion makes it visible, and every win gets a name.
Sources
The facts on this page come from these books, guides and docs:
- Fixing website speed cross-functionally, web.dev.
- Luxury retailer Farfetch sees higher conversion rates for better Core Web Vitals, web.dev.
- Implementing SLOs, Google, The Site Reliability Workbook.
- Service Level Objectives, Google, Site Reliability Engineering.
- Largest Contentful Paint (LCP), web.dev.
- Embracing Risk, Google, Site Reliability Engineering.
- Alerting on SLOs, Google, The Site Reliability Workbook.
- Example Error Budget Policy, Google, The Site Reliability Workbook.
- Changing Culture at Your Organization, Lara Callender Hogan, Designing for Performance (O'Reilly).
- T-Mobile's data-driven approach to web performance led to a 20% reduction in user site issues and a 60% improvement in visit-to-order rate, web.dev.
- LargestContentfulPaint, MDN.
- Request conditions: Test your site by blocking or throttling network requests, Chrome DevTools docs.
Coming next: Performance for designers and product managers. Design and product choices decide speed long before the code. You'll see how to talk about them.