Part of the Core Web Vitals series. For the full picture, start with Core Web Vitals: what they are, how they affect SEO and how to improve them.
Time to First Byte is the part of page speed that happens before the browser has anything to work with. No image optimisation or code splitting can make a page render before its HTML arrives, which is why a slow server quietly caps every loading metric above it.
This guide explains what TTFB measures, what a good value is, and the main ways to reduce it.
What is Time to First Byte?
TTFB “measures the time between starting navigating to a page and when the first byte of a response begins to arrive” (TTFB). It includes:
- Redirect time
- Service worker startup time, if there is one
- DNS lookup
- Connection and TLS negotiation
- The request, until the first byte of the response arrives
So TTFB isn’t only server processing time. A redirect chain, a distant server or a slow TLS handshake all count.
What is a good TTFB?
| Rating | TTFB |
|---|---|
| Good | 0.8 seconds or less |
| Needs improvement | Over 0.8 and up to 1.8 seconds |
| Poor | Over 1.8 seconds |
web.dev is clear that this is guidance, not a pass mark: “Because TTFB isn’t a Core Web Vitals metric, it’s not absolutely necessary that sites meet the ‘good’ TTFB threshold, provided that it doesn’t impede their ability to score well on the metrics that matter.”
Why does TTFB matter if it isn’t a Core Web Vital?
Because it “precedes every other meaningful loading performance metric.” In web.dev’s breakdown of LCP, TTFB is the first of four parts and ideally about 40% of the total. A 2-second TTFB leaves half a second for everything else if LCP is to stay within 2.5 s. That’s why slow-server sites struggle with LCP however much they optimise images. See how to improve LCP.
It matters for crawling too. Google’s crawl budget guidance says crawl capacity goes up “if the site responds consistently and its response times remain stable or improve” (crawl budget). See crawl budget.
How do you reduce TTFB?
web.dev’s TTFB optimisation guide lists the main levers:
| Lever | What web.dev says |
|---|---|
| Hosting | “Hosting should be the first thing you consider”: enough memory, an up-to-date backend stack |
| CDN | CDNs cache resources “on servers that are physically closer to your users” |
| Fewer redirects | “Eliminating redirects under your direct control can help to achieve a good TTFB” |
| Caching | “Even a short caching time can result in noticeable performance gains for busy sites” |
| Streaming | Browsers process markup efficiently “when it’s streamed” in chunks as it arrives |
| Service worker | A stale-while-revalidate strategy serves cached responses immediately |
| 103 Early Hints | Lets the browser start downloading “render-critical resources” while the server prepares the page |
To find where server time goes, web.dev suggests the Server-Timing header, which can report “distinct backend processes that could contribute to high latency” so they show up in the browser’s developer tools.
In practice, the biggest wins on most sites are full-page caching for pages that are the same for every visitor, a CDN in front of the origin, and removing redirect hops from internal links and common entry paths.
How do you find slow pages across a site?
There are two ways to look at it, and they answer different questions:
- Real users. PageSpeed Insights shows field TTFB from the Chrome UX Report, which includes users’ networks and redirects. In Crawlens, Measure Core Web Vitals records field TTFB alongside the Core Web Vitals, and the lab test’s TTFB, for each tested page.
- Your crawl. Crawlens times every response during the crawl and flags Slow server response (over 1 second). This is measured from your computer, not your users’, so treat it as a relative signal: sort the URLs table by Response to see which templates or sections are slowest, and compare crawls before and after a change.
Two related checks point at causes: Redirect chains and Internal links point to redirects add redirect time, and Large HTML (over 2 MB) means a long download after the first byte. For redirects, see redirect chains.
For how TTFB fits with LCP, INP and CLS, see the Core Web Vitals guide.
Checklist
- Field TTFB checked for important templates, mobile and desktop
- Slowest templates found from crawl response times
- Hosting has enough capacity and an up-to-date stack
- Pages that are the same for every visitor are cached
- CDN in front of the origin, caching HTML where possible
- No redirect chains; internal links point at final URLs
-
Server-Timingused to find slow backend steps - TTFB low enough that LCP can stay within 2.5 s
Frequently asked questions
What is a good TTFB?
web.dev recommends 0.8 seconds or less as a rough guide, and considers values over 1.8 seconds poor. Because TTFB isn't a Core Web Vital, what matters most is that it doesn't stop LCP from being good.
Is TTFB a Core Web Vital?
No. The Core Web Vitals are LCP, INP and CLS. TTFB is a supporting metric: it comes before every other loading metric, so a slow TTFB makes a good LCP much harder.
What does TTFB include?
Redirect time, service worker startup if there is one, DNS lookup, connection and TLS negotiation, and the request until the first byte of the response arrives. So it reflects the network and redirects as well as your server.
Does a CDN reduce TTFB?
Usually, by serving responses from servers closer to users and, if HTML is cached at the edge, without a round trip to your origin. It helps less for pages that must be generated fresh for every request.
Do redirects affect TTFB?
Yes. Redirect time is part of TTFB, so every hop before the final page adds to it. Linking to final URLs and collapsing redirect chains reduces TTFB for visitors who would otherwise go through them.