How to improve INP score on WooCommerce and Shopify
For e-commerce and operations managers: learn what INP measures, how to read it in field data, and which fixes on WooCommerce and Shopify make taps feel instant.
On this page
A shopper taps Add to cart and nothing happens. They tap again, the cart shows two of the same product, and some shoppers leave before paying. If a campaign is close, this is the wait to fix, and learning how to improve INP score is how you find it.
This guide is for e-commerce and operations managers who run a WooCommerce or Shopify store and do not write code. You will learn what INP measures, how to read it from real shopper data, what usually stalls the taps and which fixes fit each platform. You finish with a short list ranked by effort, ready to hand to a developer or to work through alongside one.
The short answer: INP (Interaction to Next Paint) is how fast your page answers a tap. Google calls 200 milliseconds or less good. Most slow taps come from scripts such as tracking tags, app code and heavy theme code, not from images, and a week of script work fixes many stores.
Key takeaways
- INP is the wait between a tap and the page showing a response, and shoppers feel it on Add to cart and Pay.
- Google's good threshold is 200 ms or less, judged at the 75th percentile of real visits.
- Field data from real shoppers decides what to fix, and a lab test only helps you reproduce the problem.
- Most slow taps come from scripts (tag managers, apps, plugins, theme code), so removing and deferring code comes before any redesign.
- A week of script work fixes many stores, and a rebuild is for a theme that cannot be lightened.
What INP measures and why shoppers feel it
INP measures how long shoppers wait after they tap, click or press a key before the page shows that something happened. On a store, that means the variant picker, Add to cart, the mini cart, the coupon field and the Pay button. This section gives you the definition, the numbers and the place where the wait hides.
INP in one sentence
INP is the time from a shopper's tap until the screen next updates, taken from the slowest interaction of a visit (or close to it, on pages with many taps). Google made it a Core Web Vital in March 2024, replacing First Input Delay, as web.dev's INP guide (opens in a new tab) explains. A page can load fast and still feel stuck if every tap waits behind a busy script.
That is why a store can score well on loading and still lose the sale. Loading metrics describe the first seconds. INP describes every tap after that, including the taps that spend money.
The thresholds: 200 ms and 500 ms
Google publishes three bands for INP. At 200 ms or less, the page feels responsive. Between 200 and 500 ms, it needs improvement. Above 500 ms, it is poor. Each band is judged at the 75th percentile, so three in four visits must be at or under the threshold to pass.
200ms
INP, good
Google's threshold at the 75th percentile; above 500 ms is poor
2.5s
LCP, good
Google's threshold at the 75th percentile
0.1
CLS, good
Google's threshold at the 75th percentile
INP sits beside LCP (how fast the main content appears) and CLS (how much the layout jumps while loading). If you want the wider picture, including how these three fit into search visibility, read our guide to Core Web Vitals for B2B websites. Here we stay with the tap.
Where the wait comes from
A tap has three parts, and the wait can hide in any of them. Input delay is the time the page is busy with something else before it can start on your tap. Processing is the time your click code takes to run. Presentation is the time the browser needs to paint the result.
On stores, input delay is often the largest part. A tracking script or a chat widget holds the main thread, the single lane where the browser does its work, and the tap queues behind it. The shopper sees nothing, so they tap again.
Anatomy of a tap
- 01Shopper tapsAdd to cart
- 02Input delayPage busy with a script
- 03ProcessingClick code runs
- 04Next paintCart update shows
A tap passes through input delay, processing and the next paint, and a busy script during input delay uses up the 200 ms budget
The fix is rarely to make the Add to cart button itself faster. It is to clear the lane before the tap arrives, and to keep your own click code short once it does.
How to read your INP in field data
Start with what real shoppers experienced. INP depends on the phone, the network and the scripts running during the visit, so a number from your own laptop will mislead you. This section shows where the real number lives and what to record before you touch anything.
Field data versus lab data
Field data comes from real Chrome users and is collected in the Chrome User Experience Report (CrUX), over a rolling 28-day window. Lab data is one simulated test, such as the Lighthouse run inside PageSpeed Insights. A standard lab run does not tap anything, so it cannot report INP directly. It offers proxies such as Total Blocking Time instead.
This explains a common puzzle: a store that scores green in the lab and fails in the field. Real shoppers tap while ads, chat and recommendation widgets are still loading. The lab test never does.
Find the pages and devices that fail
Three free places show field INP, and all of them use real visits:
- Search Console: the Core Web Vitals report groups your URLs by status, separately for mobile and desktop, and lists INP issues.
- PageSpeed Insights: paste a product URL and read the field data section at the top, with the mobile and desktop tabs.
- CrUX data: the source behind both tools, available when a page or your whole site has enough traffic.
Check three page types: a product page, the cart and the checkout. If a single URL has too little traffic, the tools show data for your whole site or nothing at all. In that case, judge by page type and by the group Search Console shows.
Look at mobile first. Phones have slower processors, so a script that runs quickly on a laptop can take several times longer on a mid-range phone, and most store visits happen on phones.
What to write down before changing anything
A baseline lets you show that a fix worked. Write these down in a shared document, with the date:
- Field INP on mobile for a product page, the cart and the checkout.
- LCP and CLS for the same pages, for context.
- Every third-party script on the product page, and the person or team who owns it.
- The date of your campaign, because it sets how much time you have.
If you would rather have this baseline written up by someone else, a website performance and security audit returns a written list of what to fix and what each fix costs.
The four usual causes of slow taps
Slow taps nearly always trace to code that runs on the shopper's phone, not to the size of your photos. Images affect how fast the page appears. Scripts decide how fast it answers. Four sources account for most of the slow taps we meet, and each has a different owner on your team.
Third-party scripts and tag managers
Third-party scripts are code from other companies that loads on your pages: analytics, ad pixels, chat, reviews, heatmaps, testing tools. Each runs on the shopper's phone, and several run at once. The shopper feels a tap that does nothing for a moment, then everything happens together.
A tag manager, such as Google Tag Manager, is a container that loads many of these tags at once. It is useful, and it is also where tags pile up. A tag added for a campaign two years ago can still fire on every page and every click. Ask who owns each tag and whether the campaign it served is still running.
Theme JavaScript that loads everywhere
Your theme ships its own code for sliders, mega menus, sticky bars, animated galleries and quick-view popups. Page-builder themes tend to load that code on every page, whether the page uses it or not. The shopper feels a menu that opens late or a variant picker that lags.
The question for your developer is simple: which theme scripts run on the product page, and which of them does the page need? Anything on the first list and not on the second is a candidate to remove.
Plugin and app scripts
On WooCommerce, plugins add scripts and styles to pages that do not need them: a form plugin on the product page, a slider plugin on checkout. On Shopify, apps add code to your storefront, and uninstalling an app can leave some of it behind. The shopper feels a cart that updates late.
Ask for a list of every plugin or app, what it does and the pages it needs to run on. That list is the most useful document you can give a developer, and you can start it today.
One more cause appears less often: your own click code does too much at once, for instance by recalculating a whole cart in a single step. The recording in the next section shows which cause you have.
Test with Chrome DevTools to find the culprit
A recording turns "the store feels slow" into a named script. It takes about ten minutes, and you or your developer can repeat it after every change. Use a phone profile, since that is where shoppers wait longest.
Open the page in a private window
Load a product page with browser extensions off, so your own add-ons do not add noise to the recording.
Throttle CPU and network
In DevTools, open the Performance panel. Set CPU throttling to 4x slowdown and pick a mobile network preset.
Record while the page settles
Click Record, wait until the page looks finished, and keep recording. Real shoppers tap while things are still loading.
Tap Add to cart
Tap the control that feels slow, wait for the cart to update, then stop the recording.
Read the longest task
Find the tap in the Interactions track, then the longest block of work next to it. That block names the script.
Read the long task and name the script
In the recording, the Interactions track shows your tap split into its three parts. Below it, the Main track draws the browser's work as blocks, and blocks longer than 50 ms carry a red flag. Click the longest one nearest your tap, then open the Bottom-Up or Call Tree tab. The file or domain in the details names the owner: a theme file, a plugin folder, or a provider such as a tag manager or a chat tool.
Where the long task sits tells you what to do. If it runs before your tap handler, you have input delay, and the fix is to remove or defer that script. If it sits inside the handler, the fix is to split the work into smaller pieces. If the slow part comes after the handler, the page is repainting too much at once, so reduce what changes on screen.
This three-part split is the same one in web.dev's guide to optimizing INP (opens in a new tab), which your developer can use as a checklist. Save the recording file, since it becomes your before picture.
How to improve INP score on WooCommerce
On WooCommerce you control the code, so you can fix most causes yourself or with a developer. Work in this order: remove first, defer second, split third. Each step is cheaper than the next, and the first one often needs no developer.
Load plugin scripts only where needed
Many plugins load their scripts and styles on every page. Open the Network tab on a product page, filter by JS, and list the files that come from the plugins folder. For each plugin, ask whether the product page needs it. A contact form script on a product page does not.
If a plugin does nothing your shoppers use, deactivate it. That is the cheapest fix there is. For plugins you keep, a developer can stop their scripts from loading on pages that do not need them, with a few lines of code using wp_dequeue_scriptor with a plugin that controls assets page by page. This is the routine we follow on WordPress and WooCommerce sites, and it is where many stores gain the most for the least work.
Defer and delay optional scripts
Deferring tells the browser to run a script after the page has been read, so it stops getting in the way of taps. Since WordPress 6.3, wp_enqueue_script accepts a strategy argument, so a script your theme or custom plugin registers can be deferred in one line:
add_action( 'wp_enqueue_scripts', function () {
// Register a theme script that runs after the page is parsed.
wp_enqueue_script(
'theme-gallery',
get_stylesheet_directory_uri() . '/js/gallery.js',
array(),
'1.0.0',
array(
'strategy' => 'defer',
'in_footer' => true,
)
);
} );
For third-party tags, the usual approach is to delay them until the shopper's first interaction or a few seconds after load. Leave payment and fraud scripts alone, because a delayed payment script can break the Pay button. Ask your developer to test a full checkout after every change.
In your tag manager, remove tags for ended campaigns, merge duplicates and set each tag to fire only on the pages where you use its data. Fewer tags firing on each click means a shorter queue behind every tap.
Lighten cart and checkout interactions
The cart and checkout decide the sale, so their taps matter most. Themes and plugins often refresh the cart, recalculate shipping and update the mini cart on each click. Ask your developer to check that the cart count is the only thing that happens before the screen repaints, and that heavier work (upsell lookups, analytics events) runs afterwards.
In code, that means giving the browser a chance to paint between chunks of work. This helper uses scheduler.yield() where the browser supports it and setTimeout otherwise:
// Give the browser a chance to paint between chunks of work.
function yieldToMain() {
if (globalThis.scheduler && typeof scheduler.yield === 'function') {
return scheduler.yield();
}
return new Promise((resolve) => setTimeout(resolve, 0));
}
async function renderCartLines(lines, list) {
for (const line of lines) {
const item = document.createElement('li');
item.textContent = line;
list.append(item);
await yieldToMain(); // let the screen update before the next line
}
}
Also ask whether your theme still loads the wc-cart-fragments script, which refreshes the mini cart in the background. If your theme shows no mini cart, a developer can remove it. For the full checkout picture, see our guide to speeding up WooCommerce checkout.
How to improve INP score on Shopify
Shopify hosts the store, so your control sits in three places: the installed apps, the theme and the tags. That narrows the list and makes the work quick. Shopify's developer docs publish theme performance best practices (opens in a new tab), including how to load JavaScript, and your developer can use them as a reference.
Audit apps and leftover app code
Each app can add scripts to your storefront, and some leave code in the theme after you uninstall them. List every installed app. Next to each one, write what it does, what it earns or saves you, and which pages need it. Remove the apps nobody can justify.
Then ask a developer to search the theme files (for example theme.liquid and the snippets folder) for code from apps you removed. Removing one unused app is sometimes the whole fix, and it costs nothing. If that fixes your product page, you do not need a project.
Review theme scripts and tags
Open the theme editor and look at the sections on your product page: slideshows, popups, announcement bars and recommendation blocks each load code. Remove the ones that do not earn their place on that page. Fewer sections means fewer scripts competing with the tap.
For tracking, pixels you set up under Customer events run in a sandbox, apart from your theme code. That helps keep a heavy pixel from holding up your taps, which a snippet pasted into the theme can do. Ask whoever manages your ads whether their pixels can move there.
Work within what Shopify controls
Checkout is hosted and largely controlled by Shopify, so your INP work concentrates on the product, collection and cart pages. That is where most of the scripts you added live anyway. Measure those pages in field data first, and expect the checkout to need less attention.
If the theme itself is the limit, for example an older theme with years of customisations, the next step is a cleanup by a Shopify developer or a move to a current theme. Remove and defer first, because you will learn how much of the problem is the theme and how much is what sits on top of it.
A WooCommerce product page, before and after
The values in this example are illustrative. They show how the work unfolds and are not a client result. Your numbers will differ, and the order of the steps is what carries over.
The tap that stalled
Take a store where Add to cart takes about half a second to respond on a mid-range phone. Field data shows mobile INP above 500 ms for product pages. The DevTools recording shows a long task right before the tap handler: a review widget and a chat script starting up while the shopper is already tapping.
The store has also collected tags over the years. The tag manager still fires an ad pixel for a campaign that ended long ago, on every page and every click.
The three changes made
The team made three changes, each tested before the next:
- Removed the old campaign tag from the tag manager, and deactivated a plugin whose feature nobody used.
- Delayed the chat widget until the shopper's first interaction, and stopped a form plugin from loading on product pages.
- Split the Add to cart handler so the cart count updates first, and the upsell lookup runs after the screen repaints.
| Measure | Before (illustrative) | After (illustrative) |
|---|---|---|
| Mobile INP on the product page | 620 ms | 190 ms |
| Longest task before the tap | 410 ms | 60 ms |
| Scripts loaded on the product page | 38 | 24 |
How the team confirmed it worked
After each change, the team repeated the same recording with the same throttling and compared the longest task. A lab recording confirms a fix in minutes. It shows the change took effect, and it is the quickest way to catch a change that broke something.
The field number is slower to move. CrUX works over a rolling 28-day window, so the official INP drifts down as old visits drop out. Check Search Console and PageSpeed Insights field data every week, and keep your baseline notes beside them.
What a week fixes and what needs a rebuild
Most stores before a campaign need the first column below, and some need the second. The honest way to choose is to do the first, measure again, and decide with real numbers.
Our pick for most stores before a campaign
Fixes that fit in one week
- Script audit and removal of unused plugins or apps
- Deferral of optional scripts
- Tag manager cleanup
- Splitting one or two heavy click handlers
- Before and after recordings
When the build is the limit
Rebuild or theme change
- Page-builder theme that loads the same large bundle everywhere
- Layouts that need a lot of JavaScript to show basic content
- Dozens of overlapping plugins with no clear owner
- Field INP still poor after cleanup
Fixes that fit in one week
A developer with access to your site can usually do the work in the first column in about a week, though the time depends on how many scripts you have and how tangled they are. That covers the script audit, leftover apps and plugins, tag trimming, deferral, one or two heavy handlers and a before and after recording. For many stores, that moves product and cart pages a long way.
There are no guarantees here, because every store carries a different mix of code. What the week gives you is certainty: you know what stalls the taps and what remains.
Signs the theme or build is the limit
A rebuild is the right call when cleanup cannot get you there. Watch for these signs:
- The product page needs many scripts just to show the layout.
- A page-builder theme loads the same large bundle on every page, and you cannot unload it per page.
- Several plugins do the same job, for example three sliders or two review tools.
- After removing and deferring, field INP on mobile stays above 500 ms.
If you reach that point, choosing the right partner matters more than the platform. Our guide to choosing a WordPress and Shopify development agency lists the questions to ask.
A smaller fix is sometimes the better buy. If removing one app or plugin solves your problem, do it today and skip the project. If a freelancer already looks after your store, start by asking them for the script audit.
How to brief a developer
A good brief saves the first week. Send these items together:
- Field INP on mobile for a product page, the cart and the checkout, with the date.
- Your campaign date and the pages that will take the traffic.
- The list of plugins or apps and third-party scripts, with an owner for each.
- What must not break: checkout, payment and the tracking you rely on.
- A request for before and after recordings and a written list of the changes.
Where to start this week
Start with the baseline, because every other step depends on it. Write down field INP for your product, cart and checkout pages, then run one DevTools recording on the product page. Those two actions take under an hour and tell you whether you have a script problem, a theme problem or no problem at all.
- Note field INP on mobile for a product page, the cart and the checkout
- List every third-party script and who owns it
- Remove one unused app or plugin script
- Run one DevTools recording on a throttled phone profile
- Retest after each change and write down the result
- Set your campaign date and put it in the developer brief
If you want a second pair of hands, tell us your goal and your campaign date on our page about website speed before a campaign. A person you know by name replies in under 2 hours on business days, and you hear what we found before any quote.
Frequently asked questions
What is a good INP score?
Google rates INP at 200 milliseconds or less as good, between 200 and 500 ms as needing improvement, and above 500 ms as poor. The rating applies at the 75th percentile of real visits, so three in four visits must meet it.
How do I check my INP score for free?
Paste your product page address into PageSpeed Insights and read the field data section, or open the Core Web Vitals report in Google Search Console. Both use real Chrome visits, and both need enough traffic to show a number.
Why is my INP bad on WooCommerce but fine in PageSpeed Insights lab results?
A standard lab test loads the page without tapping, so it misses the wait real shoppers feel while ads, chat and tags are still loading. Field data comes from real visits on real phones, which is why it can fail while the lab shows green.
Can Shopify apps hurt INP?
Yes. Apps can add scripts to your storefront, and some leave code behind after you uninstall them. Listing every app, removing the unused ones and checking the theme for leftover code is often the quickest fix.
Does INP affect Google rankings?
INP is one of the Core Web Vitals, which Google's ranking systems use as part of page experience. Google says relevant content still matters most, so treat INP as one signal among many that also helps your sales.
How long does it take to improve INP?
Script removal and deferral can take about a week for many stores, and a lab recording confirms the change at once. Field data covers a rolling 28-day window, so the official number takes several weeks to reflect it fully.