Quick answer: If your website feels slow after someone taps a button, opens a menu or types into a form, investigate Interaction to Next Paint (INP). Measure real mobile interactions, identify main-thread delays and heavy event handlers, reduce unnecessary JavaScript, and retest the exact user journey. Image compression and caching can improve loading, but they will not automatically fix a blocked interaction.
This practical 2026 Core Web Vitals guide focuses on WordPress and Next.js websites used by service businesses, ecommerce stores and marketing teams across Delhi NCR. It separates what the metrics actually measure from the changes most likely to help customers complete enquiries and purchases.
What is INP, and what is a good INP score in 2026?
Interaction to Next Paint measures the time from a qualifying user interaction until the browser can display the next visual update. It considers input delay, event-handler processing and the delay before the next paint. A page may load quickly but still feel frozen when someone taps “Get Quote” or selects a product variant.
Google’s PageSpeed Insights documentation classifies an INP of 200 milliseconds or less as good, above 200 through 500 milliseconds as needing improvement, and above 500 milliseconds as poor. These thresholds are assessed at the 75th percentile of real-user experiences when sufficient data is available. INP replaced First Input Delay as a Core Web Vital in March 2024.
| Core Web Vital | Good threshold | What it tells you |
|---|---|---|
| INP | 200 ms or less | How responsive the page feels after interactions |
| LCP | 2.5 seconds or less | How quickly the main visible content appears |
| CLS | 0.1 or less | How much visible content shifts unexpectedly |
These are different problems. A hero image can delay LCP; an oversized chat widget can hurt INP; an image without reserved dimensions can cause CLS. A good audit fixes the bottleneck rather than chasing one overall score.
Why slow mobile interactions cost businesses enquiries
Imagine a visitor in Noida opening a service page on a mid-range Android phone. The page appears ready, but the navigation drawer takes a moment to respond, a form dropdown freezes, and the submit button gives no feedback. Even if the backend works, the visitor may tap repeatedly, abandon the form or assume the business website is unreliable.
For a Delhi NCR business, the highest-priority interactions often include navigation, click-to-call, WhatsApp, quote forms, appointment pickers, product filters and checkout controls. Prioritize these journeys before optimizing decorative animations. Our separate guide on protecting genuine website enquiries addresses form security, which should be tested again after performance changes.
How to measure INP correctly: field data before lab guesses
- Open PageSpeed Insights. Check the exact public URL on mobile and desktop. Note whether real-user data exists for that URL or only for the origin.
- Review Search Console’s Core Web Vitals report. Look for affected URL groups and mobile trends, not a single isolated screenshot.
- Use Chrome DevTools Performance. Reproduce a slow tap or typing interaction while recording a trace. Inspect long tasks, event handlers, style recalculation and rendering.
- Capture real-user monitoring where appropriate. A small, privacy-aware web-vitals implementation can report slow interactions by route and device class without recording personal form values.
- Retest a business-critical flow. Open the menu, select a product option, submit a test enquiry and verify that the page responds and the backend accepts the action.
PageSpeed Insights uses Chrome UX Report field data over a rolling 28-day period. Lighthouse lab diagnostics are useful for finding causes, but a good Lighthouse score does not prove that actual users have good INP. New or low-traffic URLs may not have enough field samples for a reliable page-level assessment.
The three parts of a slow interaction
1. Input delay
The browser cannot begin handling the tap because the main thread is busy, perhaps parsing a large JavaScript bundle, executing analytics code or running a long task. Reduce unnecessary work at startup and split tasks that do not need to block the next user action.
2. Processing duration
The event handler itself does too much. A menu click might trigger an expensive search, repeated DOM reads, a heavy React render or synchronous validation of an entire form. Move nonessential work out of the critical handler and avoid repeated computation.
3. Presentation delay
The handler finishes, but the browser still needs to calculate styles, lay out the page and paint the result. Large DOM trees, complex transitions and layout thrashing can make the response feel late. Simplify the affected component and reserve space for elements that appear dynamically.
For a technical explanation, see web.dev’s INP reference. The metric is about the next visual response, not merely whether a click event fired.
WordPress INP fixes that do not require rebuilding the website
Audit plugins by their frontend impact. A plugin can be useful in the admin area but unnecessarily load scripts on every public page. Inspect which forms, popups, sliders, tracking scripts, chat widgets and page-builder assets execute on the pages where users report delays. Disable or defer only what testing proves safe.
Reduce page-builder and animation work. Stacked animations, scroll listeners and large nested sections can increase the amount of layout and JavaScript work. Prefer lightweight CSS interactions for simple effects, and test touch behavior on real devices.
Check third-party tags. Consent tools, remarketing pixels, heatmaps and support widgets can compete for main-thread time. Load them only where required, respect consent choices and avoid inserting duplicate containers. Delaying a tag is not acceptable if it breaks essential measurement or consent compliance.
Keep caching in its proper role. Full-page caching and a CDN often help server response and loading speed, but a page served from cache can still have poor INP if its browser JavaScript is expensive. After a change, test logged-out pages, logged-in pages where relevant, forms and checkout.
If you need a controlled update process, see our WordPress development services and website maintenance support. The objective is to remove measurable friction, not install every available optimization plugin.
Next.js and React INP fixes for 2026
Keep client components focused. Not every section needs to hydrate and run interactive JavaScript. Use server-rendered content where appropriate and isolate interactive components so a small button click does not rerender an entire page tree.
Profile before memoizing. React memoization can help specific expensive rerenders, but indiscriminate use adds complexity. Use React Profiler and browser performance traces to identify which component is actually expensive.
Defer nonurgent updates. Search filters, suggestion lists and analytics callbacks should not block immediate button feedback. Where appropriate, separate urgent UI state from lower-priority work, and keep event handlers small.
Watch third-party integrations. A headless WordPress blog may be rendered by Next.js while forms, analytics and widgets run in the browser. Optimize the public React frontend, not just the WordPress administration site. A fast CMS API response alone does not guarantee a responsive page.
Use modern image loading without confusing it with INP. The current Next.js Image component documentation notes that in Next.js 16, priority is deprecated in favor of preload. Optimize the main image for LCP, give images dimensions for CLS, and separately profile interactions for INP. Avoid applying preload to every image.
How to diagnose a slow quote form or ecommerce checkout
Start with a real task: open the page, select a service, enter details and submit. Record the interaction that feels slow and distinguish a delayed visual response from a slow network request. They are related but not identical. A form can provide immediate “Submitting…” feedback while the server safely processes the request.
- Show immediate, accessible feedback when a button is activated.
- Validate only the fields that need immediate feedback, and keep final validation on the server.
- Avoid expensive calculations on every keystroke.
- Prevent accidental duplicate submissions while preserving a clear retry path.
- Measure actual successful enquiries or purchases, not just clicks.
- Retest bot protection, email notifications, analytics and CRM delivery after optimization.
Our GA4 lead-tracking guide explains how to distinguish a completed lead from a click. Our landing-page optimization checklist covers the broader conversion journey. These topics complement INP rather than replace interaction profiling.
Common Core Web Vitals mistakes in 2026
| Mistake | Why it fails | Better approach |
|---|---|---|
| Optimizing only a desktop homepage | Mobile devices and inner pages may behave differently | Test representative mobile templates and key flows |
| Using one Lighthouse score as proof | Lab conditions do not reproduce every real interaction | Combine field data, traces and user journey checks |
| Installing several caching plugins | Conflicting settings can break scripts or forms | Change one controlled variable at a time |
| Removing all third-party scripts | Consent, analytics or support features may stop working | Audit necessity, timing and impact |
| Compressing images to fix every issue | Image weight is not always the INP bottleneck | Profile JavaScript and rendering delays |
| Claiming speed guarantees | Device, network and user behavior vary | Set measurable targets and retest |
A seven-day INP improvement plan for Delhi NCR businesses
- Day 1: Record baseline mobile INP, LCP and CLS where field data exists. List the top enquiry and purchase journeys.
- Day 2: Capture DevTools traces for slow menu, form, filter and checkout interactions.
- Day 3: Audit expensive third-party scripts, plugins and duplicate trackers.
- Day 4: Reduce main-thread tasks and unnecessary React or WordPress frontend work on a staging environment.
- Day 5: Test forms, tracking, accessibility, payments and consent flows after changes.
- Day 6: Release with monitoring and a rollback plan; compare lab traces immediately.
- Day 7: Review errors and user feedback. Continue monitoring field metrics over their normal collection window.
This is an example sequence, not a promise that every site can be repaired in one week. A large ecommerce store or complex legacy frontend may need a longer engineering investigation.
Does improving INP improve Google rankings?
Better responsiveness can improve the user experience and reduce frustration, but a good Core Web Vitals report does not guarantee a ranking increase. Google recommends strong Core Web Vitals while emphasizing that search systems consider many signals and that helpful, relevant content remains important. See Google Search Central’s page experience guidance.
Keep speed work separate from indexability checks. If a page is missing from search entirely, inspect rendering, canonical tags, robots directives and sitemap inclusion using our React, Next.js and WordPress indexing guide. Faster interactions cannot compensate for an accidentally noindexed URL.
Frequently asked questions
What is a good INP score for a business website?
At the 75th percentile, 200 milliseconds or less is good, above 200 through 500 milliseconds needs improvement, and above 500 milliseconds is poor when sufficient real-user data exists.
Can a website have good LCP but poor INP?
Yes. A page can display quickly but become unresponsive when JavaScript, event handlers or rendering work blocks the next visual update.
Does installing a WordPress cache plugin fix INP?
Not necessarily. Caching can help loading and server response, but it does not automatically remove long browser tasks or expensive click handlers.
How do I test INP in Next.js?
Review mobile field data in PageSpeed Insights and Search Console, reproduce slow interactions with Chrome DevTools Performance, and use privacy-aware real-user monitoring when needed.
Is INP the same as website loading speed?
No. INP measures responsiveness to interactions. LCP measures when the main visible content loads, and CLS measures unexpected layout movement.
Can a chat widget make INP worse?
Yes. Some third-party widgets add main-thread work, especially during initialization or interaction. Measure the specific widget before changing it.
Should I preload every image in Next.js?
No. Reserve high-priority loading for genuinely critical images. Loading too many resources eagerly can compete with other important work.
Will fixing INP guarantee more leads?
No. A more responsive form can remove friction, but offer quality, content, trust, targeting and follow-up also influence conversion. Track completed enquiries before and after changes.
Final checklist: optimize the interaction that matters
For most businesses, the right first step is not a full redesign. Identify the slowest customer-facing interaction, measure it on a real mobile device, find the blocking task, make one controlled change and verify that the enquiry or checkout still works. For WordPress and Next.js projects in Delhi, Noida, Gurgaon, Ghaziabad and nearby markets, Keshav Enterprises’ website development team can help scope a performance audit around real business journeys rather than unsupported speed promises.