What's next for web performance
Check where new performance APIs really stand, try Container Timing behind its flag, read metric changelogs, check AI tools' claims, and keep up with a few feeds.
- 01Check where a new API standsRead its chromestatus entry, its spec's status line, the engines' positions and its test results, then check real browsers.
- 02Time one part of a pageMark a section with Container Timing behind its flag, and read the entries it writes.
- 03Tell a metric change from a site changeUse the metrics changelogs before you hunt for a cause, and check an AI tool's claims against a measurement.
- 04Keep your knowledge currentPick the right feed for each question, with a routine for each one.
New APIs, and how to tell where each one stands
Ravi looks after the Leaf and Kettle shop's code. In How performance standards are made, he followed one API from an idea to a standard. This morning, Ana sends him a link. Ana works on the shop with him. "Look: Container Timing can time our reviews box. Can we use it?"
Ravi adds it to the Mint tea page and reloads. No entries come. The console shows one warning: "The entry type 'container' does not exist or isn't supported."
So he has questions. Is this API real? Is it on its way? Can his visitors get it? And there's a bigger question. New APIs and new metric rules keep coming. How does he keep up, without reading everything? This lesson answers these questions in order.
Start with a quick check. An entry type is one kind of record a browser can write, like event or long-animation-frame. Each browser lists its own in PerformanceObserver.supportedEntryTypes. Ravi asks about two new ones:
// Which of the two new entry types does this browser write?const types = PerformanceObserver.supportedEntryTypes;console.log(`soft-navigation: ${types.includes("soft-navigation")}`);console.log(`container: ${types.includes("container")}`);- Line 1 is a comment.
- Line 2 reads the list of entry types this browser can write.
- Line 3 asks about
soft-navigation. That's the record for a route change in a single-page app. - Line 4 asks about
container. That's the record Container Timing writes.
In Chrome 157, it printed soft-navigation: true and container: false. In Firefox 159 and WebKit 27.2, both lines printed false. WebKit is the engine inside Safari.
Then the course started Chrome 157 again, with one switch turned on: Experimental Web Platform features. This time, the second line printed container: true. So Container Timing is already inside Chrome. It's just switched off.
Why it matters: "on its way" can mean several things. The code can be built but switched off. It can be on for a few sites. It can be on in one browser only. Each one needs a different plan.
The course follows six APIs that are on their way. Each one is somewhere on the same road. Here they all are, at the course's last check:
Asha plans a picnic for Saturday. The forecast says sun. It's a good guide, made by people who know. But it changes during the week. So on Saturday morning, she looks out of the window. The window shows what's really there.
- In real life: The forecast for Saturday
- In JavaScript: A ship version planned on chromestatus.com
- In real life: A forecast that changes during the week
- In JavaScript: A trial that ends, or a ship version that moves
- In real life: The weather report afterwards
- In JavaScript: Release notes
- In real life: Looking out of the window
- In JavaScript: Checking a real browser for the API
A new API has a stage, not a date. Its records show the plan. A check in real browsers shows what runs. A few feeds tell you when the stage moves. The same goes for the metrics: their rules change too, and each change is written down.
How the course recorded it:
- The checks ran on the Mint tea page in Chrome 157, with and without the flag. They also ran in Playwright's builds of Firefox 159 and WebKit 27.2, one browser at a time. Playwright is a tool that drives real browsers from a script.
- Each API's plan comes from chromestatus.com, Chrome's public list of features, through its JSON API. Its switch comes from Chromium's own code.
- Each spec's stage comes from the W3C's API or the draft's own page. Each engine's view comes from its public GitHub repository. Test results come from wpt.fyi.
APIs in origin trial and in development
First, the words for each stage. You met them in How performance standards are made:
- A flag is a switch that's off unless you turn it on yourself, on Chrome's
chrome://flagspage. - An origin trial lets a site turn a feature on for its own visitors. The site sends a token, and it works for a set range of Chrome versions.
- Shipping turns the feature on for everyone.
Here is what each stage means for your visitors. Read each row across:
| Stage | What it means | Do your visitors get it? |
|---|---|---|
| An explainer only | Someone has written down the problem and an idea for the API. | No. There's nothing to run yet. |
| Behind a flag | Chrome has the code, but it's off unless you turn on a switch yourself. | No. Only people who turn the switch on. |
| In an origin trial | Sites that register get a token that turns it on, for a set range of Chrome versions. | Yes, in Chrome, on sites that send a valid token. |
| On in one browser | One engine has turned it on for everyone. The spec may still be a draft. | Yes, in that browser only. Check before you use it. |
| In several engines | Two or more engines have it on, and pass the shared tests. | Yes, in each of those engines. |
One API in an origin trial
At the course's last check, one of the six was in an origin trial: the Declarative Performance Observer. Here is the problem it solves. A page's own script usually collects its numbers and sends them. But some visits never run that script. The network can fail before the page arrives. The tab can crash. Then nothing is sent.
Its explainer proposes a fix. The server sends one HTTP header, Performance-Observer. The browser itself then collects the page's entries. It sends them when the visit ends, even after a crash. The trial runs from Chrome 151 to 161. The explainer says plainly that it "has not been approved to ship in Chrome".
There's no spec yet, only the explainer. And a page's script can't check for it. It's a header, not a JavaScript API.
Three behind a flag
Three of the six were behind the flag in Chrome 157:
- Container Timing times a part of the page that you mark. The next section tries it.
- Event Timing's targetSelector. You met Event Timing in Event Timing and INP. Each entry has a
target: the element the visitor touched. But by the time your code reads the entry, that element can be gone. Think of a cookie banner that closes when you click it. The newtargetSelectorgives a short text that describes the element instead, as a CSS selector. - LoAF style and layout times. Long animation frames, from Long Tasks and Long Animation Frames, report style and layout work as one time. The new fields split it in two,
styleDurationandlayoutDuration.
The LoAF times hold a lesson. Their origin trial ran from Chrome 148 to 153. Then came their Intent to Ship, the email that asks to turn a feature on for everyone. It got three LGTMs, "looks good to me", from Chrome's API owners. chromestatus planned them for Chrome 157. So did Chrome 157 have them? Here is the course's check for five of the six APIs:
const types = PerformanceObserver.supportedEntryTypes;const proto = (name) => globalThis[name]?.prototype ?? {};const say = (api, yes) => console.log(`${api}: ${yes ? "yes" : "no"}`);say("Container Timing", types.includes("container"));say("LoAF style and layout", "styleDuration" in proto("PerformanceLongAnimationFrameTiming"));say("Event Timing targetSelector", "targetSelector" in proto("PerformanceEventTiming"));say("Soft navigations", types.includes("soft-navigation"));say("scheduler.yield()", typeof scheduler === "object" && "yield" in scheduler);- Line 1 reads the list of entry types.
- Line 2 makes a helper. It finds the browser's type for one kind of entry, like
PerformanceEventTiming, and returns the object that holds its fields. In a browser without that type, it returns an empty object. Then the check says no instead of failing. - Line 3 makes a helper that prints the API's name, then yes or no.
- Lines 4 and 7 ask about entry types. Lines 5 and 6 ask whether an entry has a new field.
- Line 8 checks for
scheduler.yield().
In Chrome 157, only two lines printed yes: soft navigations and scheduler.yield(). With the flag on, all five printed yes. In Firefox 159, only scheduler.yield() printed yes. In WebKit 27.2, none did.
So the LoAF times weren't in Chrome 157. Chromium's own code says why. Its file runtime_enabled_features.json5 lists every switch, with a status. In Chrome 157's code, the switch for the LoAF times is experimental: on only with the flag. In Chrome 158's code, it's stable: on for everyone. It arrived one version later than planned.
Why it matters: a version on chromestatus is a plan. Plans move. The browser's code, and a check in a real browser, tell you what shipped.
Two that are on in Chrome
- Soft navigations, from Measuring soft navigations. Chrome turned them on for everyone after their trial. Their spec is still a draft in WICG, the W3C's group for new ideas. Mozilla's issue has no position yet.
scheduler.yield(), from Yielding to the main thread. Chrome and Firefox have it. WebKit 27.2 printed no.
How to read a record yourself
Here are three fields from Container Timing's entry on chromestatus.com:
// Three fields from Container Timing's entry on chromestatus.com.const record = { devTrial: 145, trial: { first: 148, last: 153 }, shipped: null };const version = 157;const inTrial = record.trial !== null && version >= record.trial.first && version <= record.trial.last;console.log(`Origin trial in Chrome ${version}: ${inTrial ? "yes" : "no"}`);console.log(`On for everyone: ${record.shipped ? `Chrome ${record.shipped}` : "not planned yet"}`);- Line 1 is a comment.
- Line 2 holds the fields: behind a flag from Chrome 145, an origin trial from 148 to 153, and no ship version.
- Line 3 is the Chrome version you care about.
- Line 4 checks whether that version is inside the trial.
- Line 5 prints
Origin trial in Chrome 157: no. - Line 6 prints
On for everyone: not planned yet.
So Container Timing's trial is over, and it hasn't shipped. It's back behind the flag. One record isn't enough, though. To check any API, look in five places, in this order:
- chromestatus.com: search for the API. Read its stages, and the Intent emails it links to.
- The spec's status line, just under its title. It says "Draft Community Group Report" for a WICG draft, or "Working Draft" at the W3C. An explainer alone means there's no spec yet.
- Mozilla's and WebKit's standards positions. A label is a position. No label means none yet.
- wpt.fyi: search for the API's tests, and see which engines pass them.
- Your own browsers: run a check like the one above, in each engine your visitors use.
Go to each engine's own record. chromestatus.com keeps a summary of other engines, and it can fall behind. For Container Timing, its WebKit field says "Neutral". WebKit's own issue has no position label at all.
Pick an API to see its whole record:
- Behind a flag from
- Chrome 145
- Origin trial
- Chrome 148 to 153
- Ship version on chromestatus
- none yet
- In Chrome 157's code
- behind a flag
What the lesson's check printed
- Chrome 157:
no - Chrome 157 with the flag:
yes - Firefox 159:
no - WebKit 27.2:
no
Container Timing times when a part of the page you mark has painted. In Chrome 157, at the course's last check, it was behind a flag. Open each record below to see where it is now.
Why it matters: each record answers one question. Only the last check tells you what your visitors get.
Container Timing: when one part of the page is ready
Back to Ana's question. The Mint tea page has a reviews box. The reviews come from a second request, after the page itself. Ana wants to know when a visitor can read them.
Can LCP tell her? No. LCP times the biggest image or block of text. On this page, that's the photo. The reviews are small. Element Timing times one element that you mark with an elementtiming attribute. But the reviews box is many elements, and most of them arrive late.
Container Timing times a whole part of the page. Its explainer says it tracks "when annotated sections of the DOM are displayed on screen and have finished their initial paint." In plain words: you mark a part of the page. Each time something new paints inside it, the browser writes an entry.
At Leaf and Kettle, a waiter keeps an eye on table 4. Each time a dish lands, he notes the time, and how much of the table is now covered. The café also times its biggest plate of the day. That timer can't tell you when table 4 got its cake.
- In real life: Table 4
- In JavaScript: The part of the page you mark with
containertiming - In real life: A dish landing on the table
- In JavaScript: Something new painting inside it
- In real life: The waiter's note
- In JavaScript: A container entry
- In real life: How much of the table is covered
- In JavaScript:
size, the area painted so far - In real life: The time of the first dish
- In JavaScript:
firstRenderTime - In real life: The café's "biggest plate" timer
- In JavaScript: LCP, for the whole page
Here is the reviews box on the Mint tea page, marked:
<section containertiming="reviews"> <h2>Reviews</h2> <ul id="review-list"></ul></section>- Line 1 marks the section with
containertiming, and names itreviews. The name comes back in every entry. - Line 2 is the heading. It's in the page from the start.
- Line 3 is an empty list. A script fills it when the reviews arrive.
And here is the code that reads the entries:
new PerformanceObserver((list) => { for (const entry of list.getEntries()) { const ms = Math.round(entry.startTime); console.log(`${entry.identifier}: ${entry.size} square px painted by ${ms} ms`); }}).observe({ type: "container", buffered: true });- Line 1 makes a
PerformanceObserver: an object that hears about new entries. - Line 2 goes through each new entry.
- Line 3 rounds its
startTime: when this paint happened, in milliseconds from the start of the visit. - Line 4 prints the entry's name, its
sizeand the time. The size is the area painted inside the box so far, in square pixels. - Line 6 asks for
containerentries, withbuffered: trueso it also gets the ones from before it started.
The course loaded the page in Chrome 157, with the flag on. Its server held the photo back 600 ms, and the reviews 1,500 ms. That's like a slow image server and a slow reviews service. The code printed two lines:
reviews: 1794 square px painted by 44 msreviews: 20778 square px painted by 1524 ms
The first entry came when the Reviews heading painted. The second came when the three reviews painted. The size grew from 1,794 to 20,778: the box was much fuller.
Each entry has two more fields worth knowing:
firstRenderTimeis the time of the first paint inside the box. It stayed at 44 ms in both entries.lastPaintedElement: Chrome sets it to the biggest element that painted for this entry. It was theh2heading, then anli, one of the reviews.
Meanwhile, LCP saw the photo at 624 ms, and stopped there. Here are the three moments, as Chrome drew them:
So LCP said 624 ms. A visitor who came for the reviews waited until 1,524 ms. That's 900 ms longer. The course loaded the page 5 times. Every load gave the same two entries, with the same sizes. Only the times moved, by a few milliseconds.
Why it matters: LCP times one thing for the whole page. Container Timing times the part your visitors came for.
When Chrome writes an entry
Chromium's container_timing.cc decides. In plain words:
- Chrome keeps one painted area for each marked part of the page.
- When an image or text inside it is painted, Chrome adds that element's box to the area.
- If the box is already inside the area, nothing changes.
- When the area has grown, Chrome writes one new entry for that part, with the new size.
So a review that paints again in the same place doesn't make a new entry. Only new painted area does. On the Mint tea page, the heading painted first. The three reviews arrived together, and painted together later. So the box got exactly two entries.
Firefox builds it too. Firefox 159 has Container Timing behind a preference, dom.enable_container_timing, which is off by default. With it on, Firefox also wrote two reviews entries: the heading, then a review.
Still changing
Container Timing's origin trial is over. The working group's minutes record how it went. GitHub and RUM Vision used it during the trial. Chromium, Firefox and Servo have their own versions. The minutes also list changes planned after the trial:
- Stop recording at the first scroll or interaction.
- Drop
intersectionRect, the box around all the paints. - Rename the fields to match LCP's and FCP's names.
- Add
element.getContainerTiming(), to read an element's latest entry. - Keep one stored entry per marked part, updated in place.
The minutes add that the new names are still open. So the names Chrome 157 uses aren't final. Why it matters: code you write against a flag is an experiment. Check for the entry type first. Read the explainer again before you rely on it.
Metric changes under discussion
APIs aren't the only thing that changes. The metrics do too. Not your site: the rule that measures it.
A metric has a road too
web.dev's Web Vitals page gives every Core Web Vital three stages:
- Experimental: a possible Core Web Vital, which can still change a lot.
- Pending: it passed testing and feedback. It stays here for at least six months, so tools can adapt.
- Stable: a Core Web Vital, like LCP, CLS and INP. The page says stable metrics "won't change more than once per year". Each change goes in the metric's changelog.
Ravi's bathroom scale gets a new spring. Overnight, he weighs two kilos less. He didn't change. The scale did. The note in the box says so, and by how much.
- In real life: Your weight
- In JavaScript: Your page's real speed
- In real life: The scale's new spring
- In JavaScript: A change to how Chrome measures a metric
- In real life: The note in the box
- In JavaScript: The metric's changelog entry
- In real life: Two kilos lighter overnight
- In JavaScript: A jump in your numbers after a Chrome update
Reading Chromium's metrics changelog
Chromium keeps a changelog for LCP, CLS, INP, FCP and soft navigations. Each entry names a Chrome version and a kind of change:
- Launch feature: something new is turned on.
- Metric definition improvement: the rule for the metric changed.
- Metric bug fix: a mistake in the measuring was fixed.
- Bug: a mistake in the measuring that started in this version.
- Implementation optimizations: Chrome changed how it does the work, which can move the numbers.
Big changes get their own page, with a part called "How does this affect a site's metrics?". Take Chrome 147's LCP change. Before it, a big photo that was still loading could hold back the LCP entries for text that had already painted. After it, Chrome reports a new candidate whenever it's bigger than anything painted so far. The page says: "No change to CrUX / UKM metrics". Your field data stays the same. But your own script gets more entries on the way.
Here are some LCP entries, and a helper that finds the ones between two versions:
// Some entries from Chromium's LCP changelog, newest first.const lcpChanges = [ { chrome: 151, kind: "Launch feature" }, { chrome: 147, kind: "Metric definition improvement" }, { chrome: 145, kind: "Launch feature" }, { chrome: 143, kind: "Metric bug fix" }, { chrome: 140, kind: "Bug" },];const between = (from, to) => lcpChanges.filter((change) => change.chrome > from && change.chrome <= to);for (const change of between(144, 151)) console.log(`Chrome ${change.chrome}: ${change.kind}`);- Line 1 is a comment.
- Lines 2 to 8 list five entries, newest first: a Chrome version and a kind of change.
- Line 9 keeps the entries after
from, up to and includingto. - Line 10 prints each one, for a visitor whose Chrome went from 144 to 151.
It prints three lines: Chrome 151: Launch feature, Chrome 147: Metric definition improvement and Chrome 145: Launch feature. Try any update in the playground below. It reads the whole LCP, CLS and INP changelogs:
LCP
- Chrome 153, metric bug fix: Fixed race conditions in presentation timestamp attribution for animated images and first video frames
CLS
No changes listed.
INP
No changes listed.
Each line is a change to how Chrome measures, not to your site. A visitor whose Chrome updated across it may report different numbers for the same page.
Why it matters: if your numbers jump right after a Chrome update, read the changelog before you hunt through your code.
Changes still being discussed
- Soft navigations in CrUX. CrUX, Chrome's public field data, publishes experimental versions of LCP, INP and CLS that include soft navigations. Its release notes say the team plans to use them in the main metrics. The web-vitals library added soft navigation support in its version 6.
- Style and layout times. At the working group's meeting, members worried that separate style and layout times differ between engines, and can mislead. One idea was a single time for both. No decision was recorded.
- One LCP candidate per paint. The LCP spec changed to report one candidate per paint. Firefox could report several for one paint, and the web-vitals library has an issue about it. Mozilla's bug tracker lists the fix for Firefox 161.
Why it matters: each of these can move the numbers in your own data one day. If you read the records, you'll see it coming.
AI in performance tools
Performance tools come with AI helpers too. Performance work with AI agents tried two of them. Here is what each one does, from its own docs:
- AI assistance is a chat panel in Chrome DevTools, powered by Gemini, Google's AI model. Its docs say it "autonomously narrows down and selects specific context", like trace events. It "can perform autonomous actions such as run audits and record performance traces." It shows its steps, and can write a prompt for your own coding agent.
- It's off until you turn it on. Its docs call it "experimental", and say it "may generate inaccurate or offensive information".
- The Chrome DevTools MCP server hands DevTools' tools to a coding agent in your editor or terminal.
The standards group talks about AI too. Its minutes record an open discussion. How do you measure a visit made by an AI agent? How do you keep bot and agent traffic out of real visitors' data? One member's view: being able to repeat a measurement quickly will matter more. The talk was exploratory, with no actions agreed.
Ben drives to a new shop with a sat-nav. It saves him a lot of map reading. Then it says "turn left", into a road that's closed. Ben looks at the signs, and takes the next turn instead. The sat-nav helped. The road had the final word.
- In real life: The sat-nav's route
- In JavaScript: An AI helper's diagnosis
- In real life: "Turn left here"
- In JavaScript: "Add a width and height to the photo"
- In real life: The road signs
- In JavaScript: The trace and the performance entries
- In real life: A road that's closed
- In JavaScript: A claim the evidence doesn't support
Whatever the tool, the course's habit stays the same: measure first. Before you act on an AI claim:
- Find the number it quotes, in a trace or a performance entry you can see.
- Check the cause: what ran just before the effect?
- Check which Chrome, and which metric rule, the number came from. A changelog entry may explain it.
- Make the change, then measure again, several times.
In Performance work with AI agents, a DevTools insight blamed an unsized photo for a layout shift. The trace showed a late promotion had caused it. An agent that trusted the insight would have passed the wrong cause on.
New AI features arrive in What's new in DevTools. Its page covers "Chrome DevTools and the Chrome DevTools MCP server". Why it matters: an AI helper can save you hours of clicking. But its words aren't a measurement. Your trace is.
Staying current
Ravi can't read everything. Nobody can. Chrome alone "ships a new milestone (major version) to the stable channel every two weeks", says Chromium's release cycle page. The trick is to know which feed answers which question.
Ana catches a train to work. The printed timetable says when it should leave. Announcements say when plans change. The arrivals board says what really came in. And the train at the platform is the one she gets on.
- In real life: The printed timetable
- In JavaScript: chromestatus.com and its roadmap
- In real life: The announcements
- In JavaScript: The Intent emails on blink-dev
- In real life: The arrivals board
- In JavaScript: Release notes for each browser
- In real life: The train at the platform
- In JavaScript: The API in a real browser
Here are eight feeds, what each one tells you, and a routine for each. Read each row across:
| Feed | What it tells you | A routine |
|---|---|---|
| chromestatus.com | Chrome's plan for each feature: flag, origin trial, the version that ships it. | Before you use a new API, open its entry. Read the roadmap for the next release. |
| blink-dev | Chrome's Intent emails, and the API owners' replies. | Search for the API's name. Count the LGTMs on its Intent to Ship. |
| The WebPerf WG's minutes | What the working group discussed, and which questions are still open. | Skim the topics of each meeting for the APIs you use. |
| Interop | Which features every engine works on together, and their test scores. | Read the focus areas when each round is chosen. Check the dashboard now and then. |
| New in Chrome and What's new in DevTools | What changed in Chrome and in DevTools. | Read them with each Chrome release. |
| Firefox and Safari release notes | What shipped in the other engines. | Read them with each release. Look for the performance APIs you use. |
| Chromium's metrics changelog | Every change to how Chrome measures LCP, CLS, INP and soft navigations. | Read it when your numbers jump after a Chrome update. |
| CrUX release notes and the web-vitals changelog | Changes to the field data, and to the library many sites use to measure. | Read the CrUX notes each month. Read the web-vitals changelog before you upgrade. |
Where to find them:
- chromestatus.com's roadmap, blink-dev and the WebPerf WG's minutes.
- Interop and its dashboard.
- What's New in Chrome and What's new in DevTools.
- Firefox release notes for developers, Safari release notes and the WebKit blog.
- Chromium's metrics changelog, the CrUX release notes and the web-vitals changelog.
Here is one simple routine to start with:
- With each Chrome release, skim What's New in Chrome, What's new in DevTools and the roadmap.
- Each month, read the CrUX release notes.
- Before you use a new API, run the five checks from this lesson.
- When your numbers move, read the metrics changelog first.
- Now and then, skim the working group's minutes for the APIs you use.
Why it matters: a few feeds, each read at the right time, beat trying to read everything.
Which feed answers this question?
Ravi and Ana wrote down eight questions. Sort each one: which kind of feed answers it?
- Which Chrome versions does this API's origin trial cover?
- Did Chrome's API owners approve shipping it?
- What did the working group decide about Container Timing's field names?
- What does Mozilla think of an API?
- Which performance APIs did the newest Firefox turn on?
- Did DevTools add a new AI feature in this Chrome release?
- Why did our LCP move after a Chrome update, when we changed nothing?
- Did CrUX add new metrics in its latest dataset?
Sort each question by the kind of feed that answers it.
Common mix-ups
- "A version on chromestatus is a promise." No. The LoAF style and layout times were planned for Chrome 157, and arrived in the code for Chrome 158.
- "Behind a flag means almost shipped." No. Container Timing went through its origin trial, then back behind the flag while its design changes.
- "If Chrome has it, it's a standard." No. Soft navigations are on in Chrome, but their spec is still a WICG draft, and Firefox and Safari don't have them.
- "If my numbers jump, my site changed." No. The rule that measures them may have changed. Read the metrics changelog first.
- "AI assistance read the trace, so its answer is right." No. Its own docs call it experimental. Check each claim against the trace.
- "Keeping up means reading everything." No. Pick the feed that answers your question, and read it at the right time.
Practice exercises
Answer first, then use the hints.
Here are the same three fields for the Declarative Performance Observer. What does line 5 print?
// Three fields from the Declarative Performance Observer's entry on chromestatus.com.
const record = { devTrial: null, trial: { first: 151, last: 161 }, shipped: null };
const version = 157;
const inTrial = record.trial !== null && version >= record.trial.first && version <= record.trial.last;
console.log(`Origin trial in Chrome ${version}: ${inTrial ? "yes" : "no"}`);
console.log(`On for everyone: ${record.shipped ? `Chrome ${record.shipped}` : "not planned yet"}`);Origin trial in Chrome 157: yes. The trial runs from 151 to 161, and 157 is inside that range.
A visitor's Chrome went from 139 to 142. What does this code print?
// Some entries from Chromium's LCP changelog, newest first.
const lcpChanges = [
{ chrome: 151, kind: "Launch feature" },
{ chrome: 147, kind: "Metric definition improvement" },
{ chrome: 145, kind: "Launch feature" },
{ chrome: 143, kind: "Metric bug fix" },
{ chrome: 140, kind: "Bug" },
];
const between = (from, to) => lcpChanges.filter((change) => change.chrome > from && change.chrome <= to);
for (const change of between(139, 142)) console.log(`Chrome ${change.chrome}: ${change.kind}`);Chrome 140: Bug. Chromium's page for it says some text's paint time was reported too early. So LCP could look better than it was, on sites whose LCP element is text. Chrome 143 fixed it.
In how many of the soft navigation test files did Firefox Nightly pass every check?
4, out of 96. Firefox doesn't write soft navigation entries, so it passes very few of the shared tests. Chrome passed far more.
A visitor's Chrome updated from 145 to 151. How many INP changes did the update cross?
3. A metric bug fix in 150, another in 148, and a definition improvement in 147. A visitor whose Chrome crossed them could report a different INP for the same page.
The reviews box gets a "Write a review" panel that Ana doesn't want to time. Which attribute leaves it out of the container?
containertimingignore. Paints inside an element with it don't count toward the container, so a side panel can't make the box look ready.
AI assistance answers a question about your trace. What is the control under the answer called, which shows the steps it took?
Show agent walkthrough (on some answers, Show thinking). It lists the code the agent ran and the data it got back, so you can check its answer against real data.
Check your understanding
For each question, ask which record would answer it.
Question 1 of 7What does line 5 of Container Timing's record example print?
Read the code, then predict// Three fields from Container Timing's entry on chromestatus.com. const record = { devTrial: 145, trial: { first: 148, last: 153 }, shipped: null }; const version = 157; const inTrial = record.trial !== null && version >= record.trial.first && version <= record.trial.last; console.log(`Origin trial in Chrome ${version}: ${inTrial ? "yes" : "no"}`); console.log(`On for everyone: ${record.shipped ? `Chrome ${record.shipped}` : "not planned yet"}`);Choose an answer to see the explanation.
Question 2 of 7chromestatus planned to ship the LoAF style and layout times in Chrome 157. What did Chrome 157 say when the course asked?
Choose an answer to see the explanation.
Question 3 of 7Why did the reviews box on the Mint tea page get two container entries?
Choose an answer to see the explanation.
Question 4 of 7Your RUM LCP changed right after a Chrome update, and you changed nothing. Where do you look first?
Choose an answer to see the explanation.
Question 5 of 7Which record tells you what Mozilla thinks of Container Timing?
Choose an answer to see the explanation.
Question 6 of 7An AI helper says: "The unsized photo caused the layout shift." What's the measure-first next step?
Choose an answer to see the explanation.
Question 7 of 7A stable Core Web Vital's rule can change. How does web.dev say such a change is announced?
Choose an answer to see the explanation.
Key takeaways
- A new API has a stage: an explainer, a flag, an origin trial, on in one engine, then in several.
- Check five places: chromestatus, the spec's status line, the engines' positions, wpt.fyi, and real browsers.
- A planned version is a plan. Chromium's code and a real check say what shipped.
- Container Timing times a part of the page you mark. It's behind a flag, and its shape is still changing.
- Metric rules change too. Chromium's changelog says how each change affects your numbers.
- An AI helper's answer is a lead. Check it against a measurement.
- Pick a few feeds, and read each one at the right time.
Remember the one-liner.
Check the stage, not the excitement: read the records, test real browsers, and follow a few feeds.
Sources
The facts on this page come from these records, standards, docs and source files:
- performance_observer.cc at 157.0.8103.52, Chromium source.
- Container Timing, Chrome Platform Status.
- Long Animation Frames style and layout duration, Chrome Platform Status.
- Exposing a string targetSelector attribute to EventTiming performance entries, Chrome Platform Status.
- Declarative Performance Observer, Chrome Platform Status.
- PerformanceSoftNavigation and InteractionContentfulPaint performance entry, Chrome Platform Status.
- scheduler.yield(), Chrome Platform Status.
- runtime_enabled_features.json5 at 157.0.8103.52, Chromium source.
- runtime_enabled_features.json5 at 158.0.8127.37, Chromium source.
- Intent to Ship: Long Animation Frames style and layout duration, blink-dev.
- Add styleDuration, layoutDuration, forcedStyleDuration, and forcedLayoutDuration (pull request 30), W3C Long Animation Frames.
- Event Timing (Editor's Draft), W3C Web Performance Working Group.
- Explainer for the Declarative Performance Observer, Chrome loading team, on GitHub.
- Container Timing: explainer and origin trial notes, w3c/container-timing.
- Container Timing API (Draft Community Group Report), WICG.
- performance_container_timing.idl and container_timing.cc at 157.0.8103.52, Chromium source.
- StaticPrefList.yaml at Firefox 159, Firefox source.
- Web Performance Working Group meeting minutes, TPAC, W3C Web Performance Working Group.
- Mozilla's positions on emerging web specifications, Mozilla.
- WebKit's positions on emerging web specifications, WebKit.
- Test results, wpt.fyi.
- Browser compatibility data, MDN.
- Web Vitals: lifecycle, web.dev.
- Web Vitals changelogs: README, lcp.md and the Chrome 147 entry, Chromium source.
- How to update Web Vitals changelogs, Chromium source.
- Report one candidate per paint (pull request 154), W3C Largest Contentful Paint.
- Multiple LCP entries emitted for no apparent reason (bug 1977827), Mozilla Bugzilla.
- web-vitals: CHANGELOG, and issues 673 and 689, GoogleChrome, on GitHub.
- CrUX release notes, Chrome for Developers.
- Chat with AI assistance, Chrome DevTools docs.
- AI assistance, Chrome DevTools docs.
- Chrome DevTools for agents (chrome-devtools-mcp), Chrome DevTools, on GitHub.
- What's new in DevTools, Chrome for Developers.
- Chrome Release Cycle, Chromium source.
- Roadmap, Chrome Platform Status.
- blink-dev, Chromium.
- Web Performance Working Group meetings, W3C Web Performance Working Group.
- The Interop Project, web-platform-tests.
- What's New in Chrome, Chrome for Developers.
- Firefox release notes for developers, MDN.
- Safari release notes, Apple.
Coming next: Project: fix a slow store. You'll take the course's slow store from failing Core Web Vitals to passing, one measured fix at a time.