BuildNot yet confirmed elsewhere1 publisher3 min readPublished
The INP bill goes to the wrong department: ad script, not RAM
A field audit write-up argues red INP scores get answered with hosting migrations, while the main-thread time is actually spent by marketing tags that never went through code review.
The Engineer · Build desk

What happened
- Research from adPerf puts advertising at more than 15 percent of the weight a browser loads for a page.
- The author reports the standard response is a hosting migration, after which the bill has doubled and the Search Console INP figure is still red.
- A Search Engine Journal audit guide cited in the piece says the cause is usually code running in the visitor's browser, not the server.
- INP is the sum of input delay, processing duration and presentation delay, each with a separate cause.
- Ranking uses CrUX field data at the 75th percentile across a 28-day window; a Lighthouse score is a simulation.
Why it matters
- cost The misdiagnosis is not refundable and it recurs: owners keep paying monthly for origin capacity that was never the binding constraint.
- constraint Every hosting variable sits behind the same single execution queue, so bought capacity cannot return time the browser spends running someone else's script.
- decision The phase split settles ownership before any contract is signed: dominant input delay makes the remedy a tag decision, not an ops one.
- exposure The deployment path consuming the most main-thread time is the one with the least review, since it runs through marketing approval rather than a pull request.
Around 88 percent of that ad weight is JavaScript [20], which puts roughly 13 percent of the browser's whole payload in ad script alone [22]. Script is the part that occupies the main thread, and the main thread is where INP is measured [7]. A heavy image is a different problem with a different owner.
That 13 percent is advertising only. It does not include the tag manager container or the video embed, which the dev.to write-up puts in the same queue for the same reason [5]. The two Core Web Vitals that get treated as one metric are not: LCP is mostly a network and asset question, INP is almost entirely a JavaScript architecture question [8]. A faster origin sends the HTML sooner and leaves the main thread exactly as busy as it was [9].
The inventory in the post is worth reading as a bill of materials. One Google Tag Manager container holding ten tags, three of which attach global listeners across the whole document [1]. A chat widget loaded synchronously in the head, because that is what the vendor's documentation said to do [2]. A remarketing pixel from a campaign that stopped eight months earlier and was never pulled [3]. According to the author, none of this surfaces in a hosting uptime report [4], which is why the monthly invoice keeps arriving at the department that cannot fix it.
The evidence path matters more than the accusation. The author's sequence: find the specific URLs with field data in the Search Console INP report rather than stopping at the URL group [13], expect contact pages, filtered catalogue pages and checkout to be the offenders because that is where interaction happens [14], then reproduce in DevTools with the Performance panel throttled 4x to 6x to imitate a mid-range device [15], and read the main thread for long tasks over 50 ms with the third-party filter on [16]. Note what the throttle does to the threshold: work that measures 50 ms on a developer laptop lands between 200 and 300 ms on the device the throttle is imitating [23]. The 50 ms line is not a lab curiosity, it is a fifth of a second of unresponsiveness on the hardware most visitors are holding.
One claim in the post is asserted rather than measured: that the fix takes a single sprint and moves no bytes to a new server [18]. No before-and-after INP delta is published to support it, and the ad weight figures are relayed from adPerf research rather than measured on any of the sites described [19][20]. What survives the scrutiny is the direction of causation, which the Search Engine Journal guide the author cites states independently [21]: the code runs in the visitor's browser, so that is where the reading has to be taken. The phase breakdown costs an afternoon of DevTools time. The migration costs every month after it.
What to watch
- Whether adPerf refreshes the ad share of page load weight, and whether the JavaScript proportion of it moves.
- A published before-and-after INP delta from a tag removal, which the piece asserts but does not measure.
- Field tooling that reports the three INP phases directly, removing the need for a throttled lab reproduction to name the culprit.
Clarity's read
What the record supports and how the coverage leans. The claims behind it follow.
Reality
- Evidence34
- Adoption
- Insufficient
- Hype gap+24
- Incentives58
- Confidence38
Claim ledger
Ranked by verification strength, evidence, and original report placement.
- [1]
In the audits described, one Google Tag Manager container held ten tags, three of which installed global listeners across the entire document.
- [2]
A chat widget was loaded synchronously in the head because the vendor documentation specified it.
- [3]
A remarketing pixel remained installed from a campaign that had stopped eight months earlier.
- [4]
None of these third-party scripts appear in a hosting uptime report.
- [5]
While the tag manager, chat widget, ad pixel and video embed are free to seize the main thread, an infrastructure upgrade only relocates the bottleneck instead of removing it.
- [6]
The author reports that after a hosting migration is complete and the bill has doubled, the INP figure in Search Console stays red.
ReportedSupportedSource: dev.to author2 sources— create a free account to open themView cited source - [7]
JavaScript is the only thing that genuinely blocks the main thread, which is where INP is computed.
- [8]
LCP is largely a network and asset problem, while INP is almost entirely a JavaScript architecture problem.
- [9]
A faster server delivers HTML earlier but does not stop the main thread from being busy.
- [10]
INP is not a single number but the sum of three phases with different causes: input delay, processing duration and presentation delay.
- [11]
If the breakdown shows input delay dominating, the problem is the task queue rather than origin response speed, and server tuning should stop; input delay is the favourite territory of third-party scripts.
- [12]
Lighthouse scores are a simulation; rankings are affected by CrUX, real visitor data at the 75th percentile over a 28-day window.
- [13]
The author's method starts in Search Console under Core Web Vitals then INP, clicking past URL groups to find specific URLs that have data.
- [14]
Contact pages, catalogue pages with filters and checkout pages are almost always the prime suspects because that is where interaction happens.
- [15]
The lab reproduction uses the DevTools Performance panel with CPU throttling of 4x to 6x to imitate a mid-range device, recording while clicking the elements visitors use most.
- [16]
In the main thread view, the target is long tasks, blocks lasting more than 50 ms, with the third-party filter enabled to separate their activity.
- [17]
What makes this category slippery is its route in: third-party scripts arrive through marketing meetings rather than through a pull request.
- [18]
The author states the problem can be fixed within one sprint, without moving a single byte to a new server.
ReportedInsufficientSource: dev.to author2 sources— create a free account to open themView cited source - [19]
Research from adPerf into the performance cost of third-party content found that advertising contributes more than 15 percent of page load weight in the browser.
- [20]
About 88 percent of that ad load weight is spent on JavaScript.
- [21]
A step-by-step audit guide published by Search Engine Journal states that the cause is often not the server but the code running in the visitor's browser.
- [22]
Ad-delivered JavaScript is therefore roughly 13 percent of total page load weight in the browser.
- [23]
Under the recommended 4x to 6x CPU throttle, work measuring 50 ms unthrottled corresponds to 200 to 300 ms.
Sources
1 independent publisher whose own reporting we read for this story.
- dev.toINP Bukan Masalah Hosting: Cara Mengaudit dan Menjinakkan Script Pihak Ketiga di Situs Bisnis
1 article · August 23, 2026
Topics and entities
Follow any of these and your For You feed starts watching them — no settings page required.
Topics
Entities
- Interaction to Next PaintFollow
- Core Web VitalsFollow
- Largest Contentful PaintFollow
- Chrome User Experience ReportFollow
- Google Search ConsoleFollow
- Chrome DevToolsFollow
- LighthouseFollow
- Google Tag ManagerFollow
- adPerfFollow
- Search Engine JournalFollow
- dev.toFollow