What Is Total Blocking Time (TBT)? A Complete Guide for Website Owners

TBT

Your page looks loaded but clicks do nothing for a moment that's TBT. Here's exactly how it's calculated (with a real worked example), what causes it, and a calculator to check your own long tasks.

Technical SEO TBT Page Speed Lighthouse

TBT carries more weight in your Lighthouse score than any other single metric, roughly 30%, yet most website owners have never heard of it. If your page looks fully loaded but clicks seem to do nothing for a moment, this is almost always the metric responsible, and it is measured in a genuinely simple, checkable way.

Total Blocking Time, or TBT, measures the total amount of time between First Contentful Paint and Time to Interactive during which the browser's main thread is blocked by tasks longer than 50 milliseconds, preventing it from responding to clicks, taps, or typing.

We covered the real-user counterpart to this metric in our INP guide. TBT is the lab-based proxy for INP, useful specifically because INP is much harder to measure before a site is live.

Advertisement
Advertisement
30%

weight TBT carries in the overall Lighthouse performance score, the highest of any metric

50ms

is the threshold a task must exceed before it starts counting toward this metric

200ms

or less is Google's recommended target on average mobile hardware

How TBT Is Actually Calculated

The formula is simpler than it sounds. For every long task, only the portion beyond the first 50 milliseconds counts.

50ms threshold
250ms
30ms
60ms
Task A → 200ms blocking
Task B → 0ms blocking
Task C → 10ms blocking

Adding those three contributions together, 200ms plus 0ms plus 10ms, produces a total blocking time of 210ms for this example page.

TBT Thresholds: Good, Needs Improvement, and Poor

Good
0-200ms
Needs Work
200-600ms
Poor
600ms+

Video: "How to Fix Interaction to Next Paint (INP) and Total Blocking Time (TBT) with Brian Jackson" featuring Brian Jackson of Perfmatters, via The Admin Bar — credit to the original creator, via YouTube

Why This Metric Is Not a Core Web Vital

This is a genuinely important distinction. Tap through both to see how this metric relates to the official Core Web Vitals.

According to web.dev's official documentation, this metric is a lab-only measurement calculated by Lighthouse during a simulated page load. It is not available in CrUX field data at all, unlike LCP, INP, and CLS.

A low reading here often correlates with a low INP, since both measure symptoms of the same underlying problem: a busy main thread. This makes it a useful early-warning signal before a site accumulates enough real traffic for INP field data to be meaningful.

Advertisement
Advertisement

The Three Most Common Causes

CauseTypical Impact
Large JavaScript bundlesA single 500KB file can block the main thread for 1-2 seconds on mobile
Third-party scriptsAnalytics, chat widgets, ad tags, and A/B testing tools frequently create long tasks
Unoptimized framework hydrationReact, Vue, or Angular initial hydration can create 200ms+ long tasks on its own

TBT Long Task Calculator

Enter the duration of up to four long tasks from your Lighthouse or DevTools performance trace to see the total.

TBT Long Task Calculator

Find task durations in Chrome DevTools' Performance panel, under the Main thread section

-- ms

Enter your task durations above and click calculate.

How to Fix High Values Step by Step

According to PageSpeed Matters' 2026 guide, three strategies address the underlying cause directly: code-splitting so JavaScript loads on demand, breaking long tasks into smaller chunks using the scheduler.yield() API, and deferring non-critical scripts until after the user actually interacts.

According to Last9's guide to fixing this metric, auditing third-party scripts specifically is often the fastest win, since tag managers, chat widgets, and marketing pixels frequently run unnecessary work on the main thread that the site owner never explicitly requested.

Advertisement
Advertisement

Why Mobile Devices Amplify the Problem

According to PageVitals' guide for website owners, mid-range phones amplify long tasks significantly, so a page that looks fine on desktop often turns out to be genuinely broken-feeling on mobile hardware.

Tracking deltas after every release matters more than watching the absolute number alone. A jump from 150ms to 350ms after a new tag deployment is worth investigating immediately, even if 350ms has not yet crossed into clearly poor territory.

Testing TBT With Real Tools

According to BrowserStack's guide to minimizing TBT, Lighthouse remains the most accessible way to measure it, either directly in Chrome DevTools' Lighthouse panel or through PageSpeed Insights, which runs Lighthouse automatically for any submitted URL.

For a more granular breakdown, Chrome DevTools' Performance panel shows every individual long task on the main thread, letting you identify exactly which script or function is responsible for a given block of blocking time, rather than relying on a single aggregated number.

According to SigNoz's complete guide to TBT, values below 200ms on mobile or 150ms on desktop indicate good responsiveness, with the desktop threshold being slightly stricter since desktop hardware is generally more capable.

TBT in a Real Client-Side Rendering Context

According to Quattr's guide to measuring and reducing TBT, single-page applications that render entirely client-side tend to show the highest values, since the browser has to download, parse, and execute a large JavaScript bundle before the page becomes interactive at all.

Server-side rendering or static generation avoids much of this problem by handing the browser ready-to-paint HTML upfront.

JavaScript in that scenario only needs to attach event handlers to already-visible content, a far smaller and faster task than building the entire page from scratch on the client.

Building an Ongoing Monitoring Habit for TBT

A single audit rarely stays accurate for long. New marketing scripts, plugin updates, and growing content complexity can all quietly push a previously healthy TBT score back into problematic territory.

Checking Lighthouse scores as part of a pre-launch checklist for any significant site change, rather than only running a review after visitors start complaining, catches TBT regressions while they are still small and easy to isolate.

FAQs on Total Blocking Time (TBT)

What is a good TBT score?
Google recommends a TBT of 200 milliseconds or less on average mobile hardware. Between 200 and 600 milliseconds needs improvement, and anything above 600 milliseconds is considered poor.
Is TBT one of the official Core Web Vitals?
No. TBT is a lab-only metric measured by Lighthouse and other synthetic testing tools. It is not available in CrUX field data, unlike LCP, INP, and CLS.
What counts as a "long task"?
Any task running on the browser's main thread for longer than 50 milliseconds. Only the portion of the task beyond that 50 millisecond threshold counts toward the total.
What is the relationship between TBT and INP?
TBT serves as a lab-based proxy for INP, the real-user Core Web Vital that measures actual interaction responsiveness. A low reading on one often correlates with a low value on the other, since both point to main-thread congestion.
What is the single most common cause of a high score here?
Heavy JavaScript execution, whether from large first-party bundles or third-party scripts like analytics and chat widgets, is the most frequently cited cause across technical performance audits.
Why does this metric weigh so heavily in the Lighthouse score?
It accounts for roughly 30% of the overall Lighthouse performance score, more than any other individual metric, because it directly captures how frozen or unresponsive a page feels immediately after it appears to finish loading.

What We Learn Today

TBT measures main-thread blocking time between FCP and TTI.

Only the portion of a task beyond 50ms counts toward the total.

Good is 200ms or less; poor is above 600ms.

It carries 30% weight in Lighthouse, more than any other metric.

It is a lab metric only; INP is the real-user equivalent.

Large JS bundles and third-party scripts are the top causes.

0 Votes: 0 Upvotes, 0 Downvotes (0 Points)

Leave a reply

Loading Next Post...
Search
Popular Now
Loading

Signing-in 3 seconds...

Signing-up 3 seconds...