Shopify INP Score Poor: Apps Causing High Interaction to Next Paint
Search intent: diagnose · Updated February 2026
Shopify INP (Interaction to Next Paint) scores are poor primarily because heavy third-party app JavaScript creates long tasks on the browser main thread. INP replaced FID as a Core Web Vital in March 2024 and measures how responsive a page feels to all user interactions - not just the first. On Shopify, apps like Yotpo, Klaviyo, PageFly, Privy, and Shogun are common INP contributors because they load large JavaScript bundles synchronously, blocking the main thread and causing interaction delays above Google's 200ms threshold.
Quick Diagnostic Checklist
- Run PageSpeed Insights on your product page - what is your INP score?
- Open Chrome DevTools Network tab - how many JS files load? Total JS size?
- List all installed Shopify apps - do you have 5+ apps with JavaScript?
- Check Google Search Console → Core Web Vitals - is INP flagged as needing improvement?
Not sure if your store has this issue?
Run a free scan to detect performance problems instantly.
What This Issue Means
INP (Interaction to Next Paint) measures the time from a user interaction (click, tap, keyboard input) to the next visual update on screen. A good INP is below 200ms; needs improvement is 200–500ms; poor is above 500ms. Unlike LCP and CLS which are load-time metrics, INP captures the entire page lifecycle - any interaction, at any time during the visit, that causes a delay counts. On Shopify stores with many apps, the cumulative JavaScript weight from review apps, loyalty apps, popups, and page builders frequently pushes INP into the "poor" range.
What Causes It (Shopify-Specific)
Multiple heavy app scripts loaded synchronously
Each Shopify app adds JavaScript to your storefront. Apps like Klaviyo (~120KB), Yotpo (~200KB), Privy (~80KB), and PageFly (~300KB) are loaded synchronously in many theme configurations, blocking the main thread and contributing to long tasks that delay user interactions.
App scripts block the main thread with long tasks
A long task is any JavaScript execution that takes more than 50ms on the main thread. During a long task, the browser can't respond to user interactions. Apps that execute large amounts of JavaScript on page load create long tasks that directly cause poor INP.
App event listeners registered on every interaction target
Some apps attach event listeners to every interactive element on the page - buttons, inputs, links. When a user clicks any element, the app's event handler runs synchronously before the browser can update the UI, adding latency to every interaction.
Render-blocking app scripts delay interactive readiness
Scripts loaded without async or defer attributes block HTML parsing, delaying when the page becomes interactive. Even after load, these scripts' execution backlog continues to compete with user interactions.
How to Detect It Manually
- 1Open Chrome DevTools → Performance tab → Record while interacting with your page (click Add to Cart, open menu, etc.)
- 2Look for long tasks (red diagonal stripes in the timeline) during your interactions
- 3Identify which scripts are executing during long tasks - hover over task blocks to see the call stack
- 4Run PageSpeed Insights (pagespeed.web.dev) on your homepage and product page - look for INP score and "Reduce JavaScript execution time" recommendations
- 5Use Chrome's Web Vitals extension - it shows real INP scores as you interact with pages
- 6Check CrUX data in Google Search Console → Core Web Vitals → see INP field data for real users
How to Fix It (Step-by-Step)
Audit your installed apps and their JavaScript weight
In Chrome DevTools → Network tab → filter by JS → reload the page - note every JavaScript file loaded, its size, and which app it belongs to. Apps contributing more than 50KB of blocking JS are INP candidates for removal or optimisation.
Defer non-critical app scripts using the defer attribute
For apps that don't need to initialise immediately (popups, review widgets, loyalty programs), load their scripts with defer or load them after user interaction. Contact your app provider to ask if they support deferred loading.
{%- comment -%} Load Klaviyo after user interaction instead of at page load {%- endcomment -%}
<script>
function loadKlaviyo() {
const script = document.createElement('script');
script.src = 'https://static.klaviyo.com/onsite/js/klaviyo.js?company_id=XXXXX';
document.head.appendChild(script);
}
// Load on first user interaction
['click', 'scroll', 'keydown'].forEach(event => {
window.addEventListener(event, loadKlaviyo, { once: true });
});
</script>Evaluate ROI vs INP cost for each heavy app
If an app adds 200ms to your INP, estimate its revenue contribution. If a Privy popup costing 150KB of JS generates £50/month while a poor INP score costs organic traffic worth £500/month, the app has negative ROI. Use tools like Lucky Orange to measure conversion impact of individual apps.
Switch from PageFly/Shogun to native Shopify sections
Page builder apps are among the heaviest JavaScript contributors. If your high-traffic pages (homepage, top collections) use PageFly or Shogun, rebuilding them with native Shopify sections can eliminate 200–400KB of JavaScript per page.
How SEOScan Detects This Issue
SEOScan fingerprints each app's JavaScript using its known CDN domains, script filenames, and inline script patterns. It classifies each detected app by its INP risk rating (high/medium/low) based on known JavaScript payload sizes and execution patterns. Stores with 3+ high-INP-risk apps are flagged with an estimated INP risk score. On Pro/Premium tiers, SEOScan uses Puppeteer to measure actual long task counts and main thread blocking time.
Example Scan Result
Description
Apps detected with high INP impact: Klaviyo (estimated 120KB JS), Yotpo (180KB), Privy (90KB), PageFly (280KB), Smile.io (60KB). Total estimated render-blocking JS: 730KB. Estimated INP risk: Poor (>500ms for click interactions on mid-range devices).
Impact
Core Web Vitals: INP likely in 'poor' range for real users on mobile. Google uses CrUX field data for ranking - if field INP is poor, this is a direct ranking factor disadvantage.
Recommended Fix
Defer Klaviyo, Privy, and Smile.io loading until after first user interaction. Evaluate replacing PageFly sections on high-traffic pages with native Shopify sections.
Why It Matters for SEO
Core Web Vital Since March 2024
INP replaced FID as a Core Web Vital in March 2024. Google uses CrUX field data for INP in its ranking signals - a poor INP score has a direct, confirmed impact on search ranking.
Mobile Impact is Disproportionate
Heavy JavaScript is most damaging on low-to-mid range Android devices with slower CPUs. If more than 60% of your traffic is mobile (common for Shopify stores), poor INP on mobile devices has outsized traffic impact.
Conversion Rate Correlation
Google studies show a direct correlation between INP and conversion rate - pages with poor INP have lower add-to-cart rates because users perceive the store as slow and unresponsive.
App Accumulation Problem
INP problems get worse over time as Shopify stores install more apps. Each app adds JS independently without knowledge of what's already installed. Periodic audits are required to prevent INP degradation.
Real-World Validation Signals
- Google confirmed INP as a Core Web Vital and ranking signal in March 2024 - stores with poor INP field data in CrUX are directly disadvantaged in ranking.
- Web.dev research shows that improving INP from poor to good can increase conversion rates by 7–24% on e-commerce sites, based on real-world experiments.
- The median Shopify store loads 8–12 third-party scripts. Stores with 15+ scripts are almost universally in the "needs improvement" or "poor" INP category on mobile.
- Chrome's long tasks API confirms that app JavaScript is the primary source of long tasks on Shopify product pages - not theme code or Shopify's own scripts.
When this may not need fixing
If your store has fewer than 4-5 apps, uses a lightweight theme, and Google Search Console shows INP in the 'good' range (<200ms) for real users, no action is needed. Also, INP is measured from CrUX field data - lab measurements (PageSpeed Insights) can be misleading. Confirm with field data before making app changes.
Frequently Asked Questions
Q: What is INP and why does it matter for Shopify?
INP (Interaction to Next Paint) is a Core Web Vital that measures how responsive your store feels to user interactions - clicks, taps, keyboard inputs. It replaced FID in March 2024. On Shopify, poor INP is almost always caused by heavy third-party app JavaScript creating main thread delays that slow down every interactive element on the page.
Q: How do I find my store's INP score?
Run PageSpeed Insights (pagespeed.web.dev) on your product page - it shows your INP score from CrUX field data (real users) if available, or a lab measurement. Also check Google Search Console → Core Web Vitals → INP tab for page-level field data across your entire store.
Q: Which Shopify apps have the worst impact on INP?
The highest INP impact apps are typically page builders (PageFly, Shogun, Gem Pages), review platforms (Yotpo), email capture tools (Klaviyo, Privy, Omnisend), and loyalty programs (Smile.io, LoyaltyLion). Impact varies by implementation - contact each app for their deferred loading documentation.
Q: Can I improve INP without removing apps?
Yes - deferring app script loading until after the first user interaction is the most effective technique without removing apps. Some apps support 'lazy loading' modes in their settings. Removing render-blocking script attributes (loading scripts with defer or async) also helps.
Check Your Store for This Issue
SEOScan automatically detects shopify inp score poor: apps causing high interaction to next paint and 2 related issues - with specific fixes for your store.
Run Free Scan