completefrontend
Open lab My progress
THE WEB PERFORMANCE FIELD GUIDE

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.

By the end, you can
  • 01
    Check where a new API standsRead its chromestatus entry, its spec's status line, the engines' positions and its test results, then check real browsers.
  • 02
    Time one part of a pageMark a section with Container Timing behind its flag, and read the entries it writes.
  • 03
    Tell 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.
  • 04
    Keep 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:

Does this browser write the two new records?Pop out in the code editor (opens in a new tab)JavaScript
// 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:

Six APIs on the road from an explainer to a second engine, at the course's last check. Container Timing: reached Explainer, Behind a flag, Origin trial; now Behind a flag. LoAF style and layout times: reached Explainer, Behind a flag, Origin trial; now Behind a flag. Event Timing's targetSelector: reached Explainer, Behind a flag; now Behind a flag. Declarative Performance Observer: reached Explainer, Behind a flag, Origin trial; now Origin trial. Soft navigations: reached Explainer, Behind a flag, Origin trial, On in Chrome; now On in Chrome. scheduler.yield(): reached Explainer, Behind a flag, Origin trial, On in Chrome, In a 2nd engine; now In a 2nd engine.ExplainerBehind aflagOrigintrialOn inChromeIn a2nd engineContainer TimingnowLoAF style timesnowtargetSelectornowDeclarative observernowSoft navigationsnowscheduler.yield()now
Each row is one API. A bar marks each stage it has reached, and now marks where it stood at the course's last check. Container Timing and the LoAF style times went through an origin trial, then back behind the flag.
Real-life analogyA weather forecast, and a look out of the window

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
The main idea

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://flags page.
  • 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:

What each stage means for a site
StageWhat it meansDo your visitors get it?
An explainer onlySomeone has written down the problem and an idea for the API.No. There's nothing to run yet.
Behind a flagChrome 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 trialSites 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 browserOne 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 enginesTwo 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 new targetSelector gives 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, styleDuration and layoutDuration.

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:

Ask a browser about five new APIsPop out in the code editor (opens in a new tab)JavaScript
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:

Container Timing's plan, for one Chrome versionPop out in the code editor (opens in a new tab)JavaScript
// 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:

How to check where any API stands, in five steps. 1: chromestatus.com, for Chrome's plan: flag, trial, ship. 2: the spec's status line, for how far the standard has come. 3: standards positions, for what Mozilla and WebKit think. 4: wpt.fyi, for which engines pass the shared tests. 5: your own browsers, for what really runs.where to lookwhat it answers1. chromestatus.comChrome's plan: flag, trial, ship2. the spec's status linehow far the standard has come3. standards positionswhat Mozilla and WebKit think4. wpt.fyiwhich engines pass the shared tests5. your own browserswhat really runs
Five places, in this order. The first four are records. The last one is the only check of what your visitors really get.
  1. chromestatus.com: search for the API. Read its stages, and the Intent emails it links to.
  2. 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.
  3. Mozilla's and WebKit's standards positions. A label is a position. No label means none yet.
  4. wpt.fyi: search for the API's tests, and see which engines pass them.
  5. 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:

Playground: where is it now?
Chrome's plan and code
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
Try it yourself
Behind a flag

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.

Recorded from chromestatus.com's JSON, Chromium's runtime_enabled_features.json5, the W3C's API and each draft's status line, Mozilla's and WebKit's GitHub issues, and wpt.fyi. The browsers ran the lesson's check one at a time.

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.

Real-life analogyA waiter who watches one table

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:

The reviews box, marked for Container TimingHTML
<section containertiming="reviews">  <h2>Reviews</h2>  <ul id="review-list"></ul></section>
  • Line 1 marks the section with containertiming, and names it reviews. 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:

Print each container entryJavaScript
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 size and the time. The size is the area painted inside the box so far, in square pixels.
  • Line 6 asks for container entries, with buffered: true so 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 ms
  • reviews: 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:

  • firstRenderTime is 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 the h2 heading, then an li, one of the reviews.

Meanwhile, LCP saw the photo at 624 ms, and stopped there. Here are the three moments, as Chrome drew them:

The Mint tea page at three moments, as real frames from Chrome 157 with the flag on. At 44 ms, Reviews heading paints: reviews: 1,794. At 624 ms, the photo paints: LCP: the photo. At 1,524 ms, the reviews paint: reviews: 20,778. LCP stops at the photo; the reviews come 900 ms later.44 msMint teaThe page's text and the Reviews heading, with no photo yetReviews heading paintsreviews: 1,794624 msMint teaThe mint tea photo has appeared; the reviews list is still emptythe photo paintsLCP: the photo1,524 msMint teaThe three reviews have appeared under the Reviews headingthe reviews paintreviews: 20,778
Real frames Chrome drew while loading the Mint tea page, each within a few milliseconds of the time above it. Shaded cards are the reviews box's container entries, with the area painted so far, in square pixels. LCP stopped at the photo. The reviews came 900 ms later.

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:

  1. Chrome keeps one painted area for each marked part of the page.
  2. When an image or text inside it is painted, Chrome adds that element's box to the area.
  3. If the box is already inside the area, nothing changes.
  4. 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.
Real-life analogyA bathroom scale that gets a new spring

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:

Which LCP changes did a visitor's update cross?Pop out in the code editor (opens in a new tab)JavaScript
// 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 including to.
  • 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:

Playground: did a metric change?

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.

Try it yourself
1 change after Chrome 151, up to 157

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.

From Chromium's own LCP, CLS and INP changelogs, at the course's Chrome release. The changelogs link each entry to its details.

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.

Real-life analogyA sat-nav, and the road in front of you

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:

  1. Find the number it quotes, in a trace or a performance entry you can see.
  2. Check the cause: what ran just before the effect?
  3. Check which Chrome, and which metric rule, the number came from. A changelog entry may explain it.
  4. 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.

Real-life analogyThe boards at a train station

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:

Eight feeds, and when to read each
FeedWhat it tells youA routine
chromestatus.comChrome'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-devChrome'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 minutesWhat the working group discussed, and which questions are still open.Skim the topics of each meeting for the APIs you use.
InteropWhich 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 DevToolsWhat changed in Chrome and in DevTools.Read them with each Chrome release.
Firefox and Safari release notesWhat shipped in the other engines.Read them with each release. Look for the performance APIs you use.
Chromium's metrics changelogEvery 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 changelogChanges 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:

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 feed answers this question?
  • 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?
Try it yourself
0 of 8 correct

Sort each question by the kind of feed that answers it.

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

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.

Exercise 1 · Warm-upA trial that's still running

Here are the same three fields for the Declarative Performance Observer. What does line 5 print?

Starter codePop out in the code editor (opens in a new tab)JavaScript
// 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"}`);

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

    Exercise 2 · Warm-upAn update across a bug

    A visitor's Chrome went from 139 to 142. What does this code print?

    Starter codePop out in the code editor (opens in a new tab)JavaScript
    // 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}`);

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

      Exercise 3 · PracticeSoft navigations in Firefox's tests

      In how many of the soft navigation test files did Firefox Nightly pass every check?

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

        Exercise 4 · PracticeINP changes across an update

        A visitor's Chrome updated from 145 to 151. How many INP changes did the update cross?

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

          Exercise 5 · ChallengeLeave part of a box out

          The reviews box gets a "Write a review" panel that Ana doesn't want to time. Which attribute leaves it out of the container?

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

            Exercise 6 · ChallengeAn AI answer's working

            AI assistance answers a question about your trace. What is the control under the answer called, which shows the steps it took?

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

              Check your understanding

              For each question, ask which record would answer it.

              The what's-next quiz · 7 questionsScore: first tries count
              1. Question 1 of 7What does line 5 of Container Timing's record example print?

                Read the code, then predictPop out in the code editor (opens in a new tab)JavaScript
                // 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.

              2. 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.

              3. Question 3 of 7Why did the reviews box on the Mint tea page get two container entries?

                Choose an answer to see the explanation.

              4. 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.

              5. Question 5 of 7Which record tells you what Mozilla thinks of Container Timing?

                Choose an answer to see the explanation.

              6. 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.

              7. 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:

              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.

              CompleteFrontend Clear concepts. Working examples.