Reduce INP score
Measurable Lighthouse uplift, gated by CI so it sticks
- Senior engineers · IST + EST overlap
- NDA on day 1
- 24-hour reply
Tell us what you need fixed
Reply in 24 hours · NDA on day 1 · No spam.
Reduce INP score — done properly, by senior engineers
To reduce INP score on a live site, Krapton’s engineers find the specific clicks, taps and key presses that feel slow and remove the main-thread work standing between each input and the next frame. Interaction to Next Paint replaced First Input Delay as a Core Web Vital in March 2024, and it is rated good at 200 milliseconds or less. Unlike FID, it observes interactions throughout the visit and reports one of the slowest, counting the full latency: input delay, processing time inside event handlers, and presentation delay until the frame is painted. High values usually trace back to long tasks from hydration, analytics fired on click, React updates that re-render large trees, or style and layout work on an oversized DOM. We start with field attribution from the web-vitals library, including Long Animation Frame entries that name the responsible scripts, then reproduce each interaction with CPU throttling in the Chrome DevTools Performance panel. Fixes include yielding with scheduler.yield(), React transitions for non-urgent updates, deferring analytics, virtualizing long lists and moving heavy computation into Web Workers. The work ends with a ranked interaction list, shipped fixes, measured results and an automated interaction check in CI.
What you're seeing
INP is bleeding north of 200ms and your interactive components feel laggy after the first paint.
Our approach
We isolate the long tasks, break up the main thread, and rewrite the worst hot-paths with proper scheduling, then track INP at the 75th percentile of real visits.
Symptoms teams come to us with
- Search Console flags an INP issue on mobile URLs while desktop results look acceptable.
- Typing into search boxes or filters lags behind the keyboard, and characters appear in bursts.
- Buttons show no visual feedback for a noticeable moment after a tap, so users tap twice.
- Performance recordings show long scripting tasks right after clicks, often from analytics or tag manager code.
- Interactions in the first seconds after load feel frozen while the page is still hydrating.
What we check first
- Event handlers run expensive synchronous work, such as filtering large arrays or formatting data, before yielding.
- A single state update re-renders a large React tree because the state lives too high up.
- Third-party scripts attach click listeners that do synchronous work before the browser can paint feedback.
- Large DOM size and forced synchronous layout make style recalculation and paint dominate presentation delay.
- Hydrating the entire page at once blocks the main thread exactly when users first try to interact.
Concrete deliverables, no fluff
Every engagement ends with measurable, documented outcomes — no black-box agency reports.
- RUM-driven audit with line-level fix list
- Implementation of every critical fix
- Before/after metrics with screenshots
- CI performance gate to prevent regression
What changes after we ship
Slow interactions named and attributed
A ranked list of the interactions behind your field INP, with the target element, event type, phase breakdown and the scripts that Long Animation Frame entries attribute to each.
Visual feedback before heavy work
Handlers update the UI first and defer the expensive part through scheduler.yield(), startTransition or useDeferredValue, so the next frame paints before the remaining work continues.
Lighter rendering after each update
Narrower re-render scopes, virtualized long lists and content-visibility on offscreen sections reduce the style, layout and paint cost that shows up as presentation delay.
Interaction checks before release
Scripted Playwright interactions record long tasks for key flows like search, filtering and add-to-cart, and a pull request fails when a flow exceeds its agreed budget.
From brief to shipped fix
A transparent, low-risk process — a senior engineer reads your brief personally, and nothing starts until you approve a written plan and price.
01
Diagnose
A senior engineer reviews your brief, reproduces the issue, and pinpoints the real root cause — not the symptom — before any code is touched.
02
Scoped plan & quote
You get a written plan to reduce INP Score, a firm timeline, and a fixed quote. Nothing starts until you approve it — no surprise invoices.
03
Ship the fix
We implement on a branch and open a pull request you review, working to your code-review standards on your repo — never a black box.
04
Verify & hand off
We verify on staging and production, share before/after evidence where it applies, and leave you a short hand-off note so the fix sticks.
Situations we handle
Search and filter heavy catalogs
Ecommerce and listing sites where each filter checkbox triggers a full product grid re-render, sorting and URL update on the main thread before anything on screen responds.
Dashboards with dense data tables
SaaS admin screens with thousands of table rows, charts redrawn on every selection, and form inputs wired to a global store that notifies every subscriber on each keystroke.
Content sites with many tags
Publisher and marketing sites where consent managers, ad scripts and tag manager triggers run on clicks, making simple menu and accordion taps feel slow on mid-range phones.
Why teams hand this task to Krapton
Senior engineers only
Your brief is read and handled by a senior engineer — no junior hand-off, no sales-rep filter in between.
Root cause, not a patch
We reproduce and fix the underlying cause, then add a guard so the same class of issue does not quietly return.
Your repo, your standards
Every change lands as a pull request you review, on your repository, following your existing review process.
NDA on day one
Confidentiality and IP are covered before we look at a single line of code. All work stays in your accounts.
Fixed quote up front
You approve a written plan and price before work starts. If scope changes, we re-quote in writing — no surprise invoices.
Proof, where it applies
Performance, SEO and reliability work ships with before/after evidence so the result is measurable, not anecdotal.
Three ways to engage
No retainer required. Pick the model that matches the work — pricing for this task starts from $500, with a fixed quote before anything starts.
Per task
Most popular
One clearly-scoped fix at a fixed price. Best when you know exactly what is broken and want it handled end to end.
- Fixed quote up front
- One PR, reviewed by you
- No retainer required
Hourly
Pay only for the hours worked. Best for diagnostics, audits, or exploratory work where the scope is still emerging.
- Weekly timesheets
- Pay for what you use
- No minimum commitment
Per sprint
A focused 1–2 week sprint when the work is bigger than one fix but smaller than a full project.
- 1–2 week blocks
- Clear sprint goal
- Scale up or stop anytime
Industry-standard stack, no proprietary lock-in
Reduce INP score — your questions, answered
How much does it cost to reduce INP Score?
Pricing starts from $500 and depends on the scope we find during the diagnostic. You get a fixed, written quote before any work begins — most engagements like this run 1–2 weeks.
How long does it take to reduce INP Score?
Typically 1–2 weeks for a focused engagement. After a short diagnostic we commit to a firm timeline so you know exactly what to expect.
How do you reduce INP score when the slow interaction cannot be reproduced locally?
We collect attribution from real sessions first. The web-vitals attribution build reports the interaction target, event type, the three INP phases and Long Animation Frame entries listing the scripts involved, which we send to your analytics or a small collection endpoint. With that evidence we reproduce the interaction on a throttled CPU in Chrome DevTools, whose live metrics view shows INP for each interaction you perform.
Is scheduler.yield() safe to use in every browser?
Use it behind a fallback. scheduler.yield() ships in Chromium-based browsers, which are also the only source of CrUX field data, while other browsers need a fallback such as a promise wrapped around setTimeout. The difference matters: scheduler.yield() resumes the yielded task ahead of other queued work, so your continuation does not wait behind unrelated scripts the way a plain setTimeout can.
Will React concurrent features alone fix poor INP?
No, they help only where updates are marked as non-urgent. startTransition and useDeferredValue let React interrupt rendering to handle new input, and selective hydration prioritizes the Suspense boundary a user interacts with. A slow synchronous event handler, an analytics call on click or expensive layout still blocks the main thread, so we use transitions for heavy list and chart updates and fix the rest directly.
Keep exploring
Related tasks and resources to plan your next step with Krapton.
Let's get this off your plate
Send a 60-second brief on Reduce INP Score and a senior engineer replies within 24 hours with a plan and a fixed quote. NDA on day one, no retainer required.