TTFB (Time to First Byte) measures how long it takes from the start of a page navigation until the browser begins receiving the response. It is a useful clue when a page feels slow, but it is not a complete measure of page speed: redirects, network setup, service workers, and server work can all affect it. Measure TTFB alongside First Contentful Paint (FCP) and Largest Contentful Paint (LCP), then investigate which part of the request is taking time.
What TTFB measures—and what it does not
For a navigation, TTFB is the interval between the start of the navigation and the arrival of the first response byte, represented by the Navigation Timing API’s responseStart value. That interval can include redirects, service-worker startup, DNS lookup, TCP and TLS connection setup, and the wait between sending the request and receiving the response. A high reading therefore does not, by itself, prove that the application server is slow.
web.dev’s guide, originally published in 2021 and updated in 2025, offers rough guidance of 0.8 seconds or less as good and more than 1.8 seconds as poor; the interval between those values needs improvement. These are not Core Web Vitals pass/fail thresholds. TTFB is not a Core Web Vitals metric, so interpret it with FCP and LCP: the important question is whether the response delays useful content from appearing. A client-rendered app that depends on JavaScript to produce meaningful initial content may benefit substantially from earlier markup. A server-rendered page may still feel responsive with a somewhat higher TTFB if it needs less client-side work. web.dev’s TTFB guide frames the goal around enabling good FCP for users, rather than requiring every site to meet a standalone TTFB threshold.
How to measure TTFB
Use repeatable lab measurements to compare changes, and field measurements to understand what real users experience. The two can differ because of location, network conditions, redirects, and cache state. Keep the URL, request type, test location, and cache conditions consistent when comparing results.
#1 Best Overall
- Used Book in Good Condition
Measure a navigation in browser code
For a navigation request, read responseStart from the Navigation Timing API. A PerformanceObserver can observe navigation entries as they are recorded. Alternatively, the web-vitals JavaScript library provides an onTTFB callback. For field data, the Chrome User Experience Report (CrUX) and web-vitals are among the tools identified by web.dev.
Inspect requests in DevTools or WebPageTest
For a controlled lab check, use Chrome DevTools’ Network panel or WebPageTest. Inspect the navigation request and its timing phases rather than treating the final TTFB number as a diagnosis. Repeat tests with the same redirect path and cache conditions; a warm cache hit and an origin request do not represent the same path.
Rank #2
Measure individual resources carefully
For non-navigation resources, use Resource Timing entries. Some entries report responseStart as zero, including cached resources or cases where timing information is unavailable. Cross-origin resource timing may be restricted unless the responding server sends a Timing-Allow-Origin header. CrUX and similar field sources may report only the main navigation request, not every subresource.
Compare like with like
- Separate lab runs from field data, and note which field percentile you are examining.
- Record whether the request is a navigation or a subresource, whether it used a warm edge cache or an origin/cache bypass, and whether redirects occurred.
- Account for user and server geography, since distance and network conditions affect delivery.
- Consider whether the site is server-rendered or client-rendered, and whether early HTML is useful before JavaScript runs.
- Review TTFB with FCP and LCP, not in isolation.
How to diagnose a high TTFB
Start by determining which request phase is slow. Check for redirects, connection setup and geographic distance, service-worker behavior, cache status, and backend work. Field data can surface conditions—such as users reaching the site through a longer redirect path—that a single local lab run does not capture.
Recommended Free Tools
Rank #3
Expose backend timing
A Server-Timing response header can report selected backend operations, such as database work. Browser timing APIs and Chrome DevTools can expose those values, helping distinguish application work from network and connection time. If adding Server-Timing is impractical, application performance monitoring (APM) can provide an alternative view of backend operations. web.dev’s TTFB optimization guide describes both approaches.
How to improve TTFB
Choose an optimization that addresses the slow phase you found. A CDN, hosting change, or code change is not automatically useful; the benefit depends on whether the measured bottleneck is cache behavior, origin distance, backend work, or something else.
Remove redirects you control
Each redirect adds a step before the browser reaches the final response. Where possible, update links and routing so users request the final destination directly, and avoid unnecessary redirect hops.
Use edge caching when freshness allows
A CDN edge cache can serve repeat requests without contacting the origin on every visit. Even short-lived caching can reduce origin work for later visitors when content changes frequently. Set cache behavior to match freshness requirements, and use an origin request or cache bypass when you need to diagnose origin response time separately from cache-hit performance.
Free tools Windows power users keep installed
One-click scans. No signup required.
Best Value
Send response markup as it is ready
Streaming lets the browser begin parsing response chunks before the entire response has been generated. Look for backend work that blocks the first bytes and avoid unnecessary buffering that holds ready markup until the whole response is assembled.
Use 103 Early Hints selectively
HTTP 103 Early Hints can let supporting browsers begin fetching render-critical resources while backend work continues. This is less useful for a static site with little backend preparation. It can also make the measured TTFB appear fast while the origin is still working: track actual server time with Server-Timing or finalResponseHeadersStart so the early hint does not conceal a slow final response.
Check whether the change helped users
After an adjustment, compare measurements under the same request, location, redirect, and cache conditions. Confirm whether field TTFB changed and whether FCP or LCP improved. A lower TTFB alone does not guarantee that a page will feel faster; the rendering strategy and work the browser must do after receiving the response matter too.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →
