In short and in plain language
Some phones are slow. A shop can lag on them. This can happen even when the shop is fast in a test.
Chrome can now report a level for the device. The level says how strong the processor is. The processor is the part of the device that does the math.
On a weak level, the shop loads heavy parts later. A chat then starts only after a click. Moving effects stay off. All content and prices stay the same.
Firefox and Safari do not report a level. They get the normal shop.
After that, we measure real visits. That way we can see if the shop reacts to clicks faster.
In the lab the shop is fast, yet on a customer's older smartphone the product gallery stutters, the menu opens late and the buy button responds only after a noticeable pause. The gap rarely comes from the network alone. It comes from processing power: the same JavaScript, the same animations and the same third-party scripts land on processors that work considerably slower than the device the shop was built on. Until now a page had no clean way to tell what hardware it was running on. Chrome 152 adds a dedicated interface for that (Chrome for Developers): the CPU Performance API reports a coarse performance tier for the device. This article explains what the tier tells you and what it does not, how it works together with Compute Pressure, which heavy parts of a shop can be deferred per tier, what the fallback for unsupported browsers looks like and how to prove the result with real INP field data per device class.
Key takeaways
- Since version 152 (Chrome for Developers), Chrome exposes a device performance tier through
navigator.cpuPerformance: 1 to 4, plus 0 for unknown; stronger tiers will be added later (WICG). - The tier is static and describes the hardware class, not the current load. At runtime, Compute Pressure adds the states nominal to critical, in Chrome from 125 but only on desktop (MDN Browser Compat Data).
- Deferring pays off on weak tiers: no decorative animations, a gallery instead of a 3D view, zoom only on tap, chat and other third-party scripts only on click, no prefetching. Content and prices stay the same for everyone.
- Firefox and Safari do not support the interface (MDN Browser Compat Data), and WebKit opposes the proposal (WebKit Standards Positions). Without a value, or with 0, every browser gets the standard profile rather than a stripped-down version.
- Users can override the reported tier in Chrome's Performance settings, administrators through the
CpuPerformanceTierOverridepolicy (Chrome for Developers). The tier is a hint, not a verdict on the device. - Success shows in the field: measure INP at the 75th percentile per tier with a target of at most 200 milliseconds (web.dev). CrUX only separates phone, tablet and desktop (Chrome for Developers), so the tier belongs in your own monitoring.
Why good lab scores fall short on older smartphones
Field data shows the gap clearly. On desktop, 97 percent of websites reach a good INP score (Web Almanac 2025), on phones only 77 percent (Web Almanac 2025). For mobile secondary pages, which include category and product pages, the figure is 69 percent (Web Almanac 2025). That is exactly where the components that consume processing time live: filters, galleries, zoom, variant pickers and recommendations.
The bottleneck is the main thread. Any task longer than 50 milliseconds counts as a long task (web.dev), and on a weak processor a short task quickly turns into a long one. A click that lands in such a task waits until it is done. The same script that barely registers on the development team's machine can noticeably delay every input on a budget smartphone.
How wide the gap gets in the lab, why a device from the development team is the wrong yardstick and how to choose a suitable reference device is covered in the article Target device, not test device. This article covers the next step: the page detects the device class itself and delivers accordingly. Signals for network quality and data saving already exist, and the article Adaptive loading covers them. A reliable signal for processing power was missing until now.
The existing workarounds are crude. navigator.hardwareConcurrency reports the number of logical cores, but Safari clamps the value to 4 or 8 cores (MDN Browser Compat Data). Many cores also do not mean that each core is fast. Custom micro-benchmarks in the browser consume exactly the processing time weak devices lack, and they fluctuate with load. The explainer for the new interface names this effort explicitly as a motivation: applications should no longer need to estimate hardware with their own benchmarks (WICG).
What the CPU Performance API reports
The interface is deliberately small. It adds a single attribute to navigator, navigator.cpuPerformance, which returns a small integer. According to the explainer there are four tiers from 1 to 4, and the value 0 stands for an unknown tier if the browser cannot classify the device (WICG). Higher values mean more capable devices. Applications should expect more tiers: when considerably stronger hardware appears, a tier 5 will be added and later a tier 6 (WICG), instead of downgrading existing devices.
Chrome has shipped the interface since version 152 (Chrome for Developers). The stable release came out on August 25, 2026 (Chrome for Developers), and the release notes for Chrome 152 list the CPU Performance API under performance and networking (Chrome for Developers). The Chrome Platform Status entry names desktop, Android and WebView as platforms (Chrome Platform Status). How a device is mapped to a tier is described in the Community Group specification: the basis is the number of cores reported by the operating system (WICG). If a CPU model performs substantially better or worse than is typical for its core count, browsers may adjust the tier, typically by no more than one tier up or down (WICG).
Two properties matter for shops. First, the tier is stable: a device should stay in the same tier even when the battery is low or other applications are running (WICG). It describes the hardware class, not the current load. Second, it is kept coarse to make it harder to recognize individual devices. Each tier should cover devices on the order of a few hundred different CPU models (WICG). The interface is only available on pages served over HTTPS (WICG).
In practice, one lookup with a case distinction is enough. The important part is to separate three cases cleanly: the browser does not know the interface, the browser knows it and reports 0, or it reports a tier. The following script translates the value into one of three delivery profiles and writes it as an attribute on the html element.
// Run in the document head, before the stylesheets
// undefined = browser without the API, 0 = tier unknown
const tier = 'cpuPerformance' in navigator ? navigator.cpuPerformance : undefined;
function deliveryProfile(value) {
if (value === 1 || value === 2) return 'lite';
if (value >= 4) return 'full'; // includes future tiers 5, 6 ...
return 'standard'; // tier 3, tier 0 and browsers without the API
}
document.documentElement.dataset.profile = deliveryProfile(tier);The script treats values above 4 like the highest known tier. That follows the explainer's advice to plan for future tiers from the start (WICG). A switch that only knows the values 1 to 4 and sends everything else to a special branch would accidentally treat a next-generation device like an unknown one.
Static and dynamic: tier plus Compute Pressure
The tier answers how powerful a device is in principle. How the device is doing right now is answered by a different interface: Compute Pressure. The Chrome blog names the combination of both explicitly (Chrome for Developers). The W3C specification defines the states nominal, fair, serious and critical for this (W3C). At serious, load is consistently highly elevated and the system may be throttling to reduce heat; at critical, the device is so hot that it needs to cool down (W3C).
The explainer illustrates the interplay with an effect that needs a lot of processing power: at load time the tier decides whether the effect may start at all, and at runtime an observer turns it off at serious or critical and back on at nominal or fair (WICG). For a shop, the pattern fits anything that computes continuously: a 3D configurator, a background animation, a video in the header or a live preview while customizing a product.
// Rich effects only outside the lite profile, throttled at runtime
const profile = document.documentElement.dataset.profile;
let richEffects = profile !== 'lite';
if (richEffects && 'PressureObserver' in window) {
const observer = new PressureObserver((records) => {
const state = records.at(-1).state;
richEffects = state === 'nominal' || state === 'fair';
document.documentElement.toggleAttribute('data-calm', !richEffects);
});
observer.observe('cpu', { sampleInterval: 2000 }).catch(() => {});
}One limitation matters: in Chrome, Compute Pressure is available from version 125 on desktop only, and Chrome for Android does not support PressureObserver (MDN Browser Compat Data). On smartphones, which is where weak devices mostly are, only the static tier of the two signals remains. Embedded third-party content cannot use Compute Pressure by default; access is granted with the allow="compute-pressure" attribute on the iframe (W3C). A widget in a foreign frame only sees the state if the shop explicitly allows it.
What can be deferred per tier
The tier is only as useful as the decisions attached to it. A practical approach is not to build a separate page for each tier but to define three delivery profiles: lite for tiers 1 and 2, standard for tier 3 and for every browser without a value, full from tier 4. Which tier gets which profile is the shop's decision, not the interface's. The explainer, too, stresses that the meaning of the tiers differs from one application to the next (WICG).
| Component | Lite (tiers 1 and 2) | Standard (tier 3, value 0, no API) | Full (tier 4 and up) |
|---|---|---|---|
| Animations | decorative motion off, short transitions | transform and opacity only | richer effects allowed |
| Product images | gallery with fixed images, zoom on tap | gallery with zoom on click | full gallery, zoom prepared |
| 3D and spin view | preview image, starts on tap only | starts on click | prepared after load |
| Prefetching | off | prefetch on clear intent | prerender via Speculation Rules |
| Chat and third-party scripts | facade, script on click only | after the first input | after the first input |
| Reviews and recommendations | when scrolled into view | when scrolled into view | after load |
Animations: Non-composited animations, which recalculate layout or color on the main thread, appear on 40 percent of mobile pages (Web Almanac 2025). On a weak device they compete directly with input. In the lite profile decorative motion goes away, while necessary transitions stay short and run only on transform and opacity. If you already honor a request for less motion via prefers-reduced-motion, you can attach the same CSS rules to the profile. How to build animations without jank is explained in the article Smooth animations.
Gallery and 3D view: A 3D view loads a model, textures and a rendering library and keeps computing as long as it is visible. In the lite profile, the regular image gallery takes its place, with a "Start 3D view" button. The content stays available, it just no longer costs anything at load time. Zoom works the same way: instead of preloading the high-resolution image for every shot, it arrives on tap. How gallery and zoom work together without slowing the page is covered in the article Product gallery and zoom.
Prefetching: Prefetch and prerender speed up the next navigation, but a prerendered document already builds DOM, styles and scripts in the background. On a weak device, exactly that work can slow down the current page. In the lite profile prefetching stays off, in the standard profile it is limited to prefetch on clear intent, and only the full profile adds prerender rules. How Speculation Rules are structured is shown in the article Speculation Rules.
Chat and third-party scripts: At least 90 percent of pages include content from third parties (Web Almanac 2025). Chat windows, review widgets and video embeds bring their own JavaScript, which the shop cannot keep lean itself. In the lite profile a facade sits in their place, a simple element that looks like the widget, and the script loads only on click. In the standard and full profiles it may load after the first input. Which scripts are needed at all is covered in the article Trimming third-party scripts.
On top of that comes code the page does not use at all. The median mobile page loads 251 KB of unused JavaScript, measured uncompressed (Web Almanac 2025). Every script has to be downloaded, parsed, compiled and executed, whether it contributes anything or not. A profile that loads whole components through dynamic imports instead of upfront saves this work where it costs the most.
Content stays the same
Implementing the profile in the front end
Technically, a small script in the page head that reads the tier and sets the profile as an attribute is enough. It has to run before the first render so that CSS rules apply without a visible switch, and it must cause hardly any work itself. Everything else hangs off this attribute: CSS turns animations off, and components check the profile before they load heavy modules.
/* Lite profile: decorative motion off, necessary transitions short */
:root[data-profile="lite"] .deco-motion,
:root[data-calm] .deco-motion {
animation: none;
}
:root[data-profile="lite"] .product-card {
transition-duration: 0.1s;
}
/* A request for reduced motion applies regardless of the tier */
@media (prefers-reduced-motion: reduce) {
.deco-motion { animation: none; }
}For a 3D view or a configurator, the same principle applies in JavaScript. The module lives in its own file and is loaded through a dynamic import. In the full profile the import starts as soon as the browser has spare time, in all other profiles only on click. The button is in the HTML in every profile, so nobody goes looking for a feature that is actually there.
// 3D view: prepared after load in the full profile, otherwise on click only
const profile = document.documentElement.dataset.profile;
const start = document.querySelector('[data-viewer-start]');
let viewer;
function mountViewer() {
viewer ??= import('./product-viewer-3d.js')
.then(({ initViewer }) => initViewer(document.querySelector('#product-viewer')));
return viewer;
}
// The button works in every profile, the full profile also preloads while idle
start.addEventListener('click', mountViewer, { once: true });
if (profile === 'full' && 'requestIdleCallback' in window) {
requestIdleCallback(mountViewer, { timeout: 3000 });
}For the server, the page stays the same. That is intentional: if the server delivered different HTML per tier, it would need the tier on the very first request, for example through a cookie, and every cache would have to keep the variants apart. How quickly such a cookie wrecks the hit rate is shown in the article Why one cookie wrecks your cache hit rate. Uniform HTML with decisions made later in the browser keeps the cache shared and the first response independent of the device.
In Shopware, the profile script can be included in the theme head. Custom storefront plugins check the attribute before they initialize zoom, gallery extensions or widgets. Whether the effort pays off is decided by measuring the page types with the most interactions, usually listing and product page. More on the platform is on the page about Shopware performance.
Fallback for browsers without support
So far the interface is a Chrome feature. Firefox and Safari do not support navigator.cpuPerformance, and neither does Safari on the iPhone (MDN Browser Compat Data). WebKit has publicly opposed the proposal (WebKit Standards Positions), and Mozilla has not taken a position yet (Chrome Platform Status). The specification is being incubated in a Community Group and is not an approved standard (Chrome Platform Status).
This leads to the most important rule of the rebuild: progressive enhancement. If the value is missing, the browser gets the standard profile, the version all visitors get today. The same applies to the value 0, which Chrome uses to report an unknown tier (WICG). In its example the explainer treats unknown devices like strong ones (WICG); for a shop, the standard profile is the more cautious choice because it neither strips features nor adds load.
For the standard profile this means it has to be lean anyway. The tiers do not replace basic optimization, they only distribute what goes beyond the standard profile. Anyone trying to rescue a shop with slow interactions through the tiers alone shifts the problem onto every device that reports no tier. The basics, from long tasks to event handlers, are summarized in the article Optimizing INP.
A second fallback concerns timing. Setting the profile only after the page has been painted causes a visible switch, for example when an animation starts briefly and then stops. That is why the profile script sits inline in the head, before the stylesheets, and does nothing but read and set. A strict Content Security Policy needs a hash or a nonce for exactly this script.
Users and administrators have the final say
The reported tier is not locked in for the user. They can override it in Chrome's Performance settings (Chrome for Developers). Administrators control it through the CpuPerformanceTierOverride enterprise policy (Chrome for Developers), which according to Chrome Platform Status takes precedence over the user setting (Chrome Platform Status).
For the shop, this means the tier is a hint, not a verdict. A customer with a weak device who still wants the 3D view gets it with a click. A customer with a strong device who prefers less motion sets prefers-reduced-motion, and that wish takes priority over the tier. The same goes for data saving: if the browser signals Save-Data, prefetching stays off no matter which tier the device has.
A visible toggle for elaborate components helps, such as "Show animated preview" on the gallery. It makes the decision transparent and prevents customers from missing a component without knowing why it is not there. The choice is sensibly stored locally in the browser rather than in a cookie that travels with every request.
Where the tier reaches its limits
The tier measures the CPU and only the CPU. GPU performance, memory and power consumption are explicitly not part of this version (WICG). WebKit gives this among its reasons for opposing it: a device with a weak CPU can have a strong GPU, and sites might draw the wrong conclusions and needlessly degrade their features (WebKit Standards Positions). For a 3D view that mostly taxes the GPU, the CPU tier is only part of the picture.
The network is left out as well. A strong device on a weak mobile connection needs light images, a weak device on Wi-Fi mainly needs little JavaScript. The tier complements the network signals, it does not replace them. Interest in such device signals is real: the Device Memory API, a related signal for memory, is used by 6.3 percent of mobile pages (Web Almanac 2025).
Finally, privacy. Every additional device property makes visitors a little more distinguishable, even if the tiers are coarse. If you write the tier into your own monitoring, treat it like other device characteristics, analyze it only in aggregate and do not store it longer than the analysis requires. What to consider when measuring without consent is covered in the article Performance measurement without consent.
Measuring success with INP field data per tier
Whether the profiles work shows up not in the lab but in real visits. An INP of at most 200 milliseconds is good (web.dev), a value above 500 milliseconds is poor (web.dev). It is assessed at the 75th percentile of page loads, segmented across mobile and desktop (web.dev).
Public field data only helps roughly here. The Chrome UX Report distinguishes three form factors, phone, tablet and desktop, inferred from the user agent string (Chrome for Developers). It knows no CPU tier, so a budget phone and an expensive one land in the same group. That is why the tier belongs in your own monitoring: every interaction value the shop collects from the field gets tier and profile as additional dimensions. How your own field data and CrUX complement each other is described in the article RUM vs. CrUX.
// Approximation: longest interaction per page view, tier and profile as dimensions
const tier = 'cpuPerformance' in navigator ? String(navigator.cpuPerformance) : 'none';
const profile = document.documentElement.dataset.profile;
let longest = 0;
new PerformanceObserver((list) => {
for (const entry of list.getEntries()) {
if (entry.interactionId && entry.duration > longest) longest = entry.duration;
}
}).observe({ type: 'event', durationThreshold: 40, buffered: true });
addEventListener('visibilitychange', () => {
if (document.visibilityState !== 'hidden' || longest === 0) return;
navigator.sendBeacon('/rum', JSON.stringify({
metric: 'interaction', value: Math.round(longest), tier, profile,
page: document.body.dataset.pageType,
}));
longest = 0;
});The example uses the longest interaction as an approximation. INP itself ignores the longest interaction for every 50 interactions on pages with many interactions (web.dev); on product pages with few clicks the difference is small. If you want to send measurements without slowing the page, the article fetchLater describes an alternative to the beacon.
The analysis runs per tier and per page type: how high is the 75th percentile on product pages for tiers 1 and 2 before and after the lite profile? A control group is essential. If a small share of weak devices keeps running the standard profile, the comparison separates the effect of the profile from season, assortment and campaigns. Without that group, a before-and-after comparison in November mostly measures Black Week.
Beyond the interaction value, long animation frames are worth a look because they show which component costs the time. How to analyze them in the field is explained in the article Long Animation Frames. For a quick check on your own device with a throttled CPU, the live metrics in the browser help. The single most important interaction remains the buy button; how to make it respond quickly is shown in the article INP on the buy button.
Six steps to a tier profile
- Measure the baseline: Record interaction values and long tasks per page type, with the tier as a dimension from now on. Without a baseline, no effect can be proven.
- List the heavy components: Animations, 3D and zoom views, galleries, prefetching, chat and review or recommendation widgets, with their share of script time and bytes.
- Define the profiles: Lite, standard and full with a table like the one above, agreed with marketing and sales so that no component disappears unnoticed.
- Add the profile script: Read the tier, set the profile on the
htmlelement, use the standard profile for the value 0 and for browsers without support. - Wire up the components: Attach CSS rules and dynamic imports to the profile, use facades for chat and video, control prefetching per profile.
- Prove the effect: Analyze INP at the 75th percentile per tier with a control group and adjust the profiles afterwards.
Shortly before Black Week, a large rebuild is risky. With manageable effort you can roll out measurement with the tier and the chat facade; the profiles for gallery and prefetching follow once field data from the sale week is in. Our approach is described on the page about front-end optimization, the technical analysis delivers a first assessment of the bottlenecks, and how the metrics relate to the ranking signal is explained on the page about Core Web Vitals.
Sources and documentation
hardwareConcurrency counts logical cores, deviceMemory reports rounded memory. According to the specification the tier also starts from the core count, but it groups it into a coarse class and may correct it by CPU model, without revealing the model or the exact core count (WICG). That makes it the more direct signal for decisions about processing load, while deviceMemory remains the signal for memory questions.Related Articles
Live metrics in the browser: check LCP, INP, and CLS
Lighthouse shows one number, Search Console another: how to read Live Metrics in Chrome, add CrUX field data, and test five click paths through your shop.
Add to Cart Without the Wait: Lower INP on the Buy Button
Nothing happens after tapping add to cart? Break the buy button down into the three INP phases, give instant feedback and block double taps before Black Week.
Mega Menus as a Speed Brake: Shipping Lean Navigation
Hundreds of categories on every page, often twice: how to measure the nodes in your navigation, limit its depth and load deeper levels only on demand.