
What Is TTFB (Time To First Byte)? What's Good, and How to Reduce It (2026)
- vuetelemetry
- Guides
- 6 min read
TTFB is the time from requesting a page to receiving the first byte of the response. What it measures, what counts as a good TTFB (under ~800ms), how it feeds LCP, and the server, caching and CDN levers that reduce it.
TTFB, or Time To First Byte, is the time between the moment your browser asks a server for a page and the moment the first byte of the response comes back. It is measured in milliseconds and covers everything that must happen before the browser can even start reading the page: resolving the domain, opening the connection, and - the part that usually dominates - the server doing its work and sending out that first byte.
It matters because TTFB is the tax paid on every single request before anything visible can happen. A browser cannot render a single pixel until bytes start arriving, so a slow TTFB delays the whole page by that amount, no matter how well optimised your images, CSS and JavaScript are. It is the floor under your loading speed.
Need a server you control for this? Contabo Cloud VPS: full root access and its own public IPv4 (affiliate link).
What TTFB actually measures

Under the hood, TTFB is a sum of smaller waits: any redirects, the DNS lookup that turns your domain into an IP address, the TCP connection and TLS handshake that secure it, the time the request spends travelling to the server, and finally the server processing time until the first byte is written back. On most sites that last piece - how long the server takes to build the response - is the largest and the most fixable.
Crucially, TTFB is a back-end and network measurement, not a front-end one. If your TTFB is high, the problem is on the server, the hosting or the network path, not in your React or Vue code. That is a useful diagnosis: it tells you to look at your host, your caching and your database rather than at your bundle size.
What counts as a good TTFB
Google's guidance, published on web.dev, is that a good TTFB is roughly under 800 milliseconds for most sites, with anything above 1.8 seconds considered poor. These are field thresholds - measured on real visits - so they already account for real networks and devices rather than a lab test on fast hardware.
- Slow or overloaded hosting - a shared server straining under other sites' traffic
- Uncached dynamic pages regenerated from scratch on every single request
- Heavy database queries or slow back-end code inflating server processing time
- No CDN, so every visitor connects to one distant origin server
- Redirect chains that add extra round trips before the real response begins
- Slow TLS handshakes or a server located far from most of your audience
TTFB is not itself one of the three Core Web Vitals, but it feeds directly into Largest Contentful Paint. LCP can never be faster than the TTFB that precedes it, because the main content cannot appear until the response has started. Improving a slow TTFB often lifts LCP for free, which is why performance work so often starts here.
How to reduce TTFB
The biggest server-side lever is caching. Serving a page from a full-page cache or a CDN edge cache skips the work of regenerating it on every request, turning hundreds of milliseconds of processing into a near-instant hit. Beyond that, faster or less crowded hosting, leaner back-end code, and trimming slow database queries all cut the processing portion directly.
On the network side, a CDN shortens the physical distance between your server and each visitor, so the request and response travel less far. Modern connection handling - HTTP/2 or HTTP/3, keep-alive, and a well-configured TLS setup - reduces the handshake overhead, and where a page can be pre-rendered to static files, static hosting removes server processing from the critical path almost entirely.
The bottom line
In short, TTFB is the server-response tax on every page you serve, and it sets the ceiling for how fast the rest of your site can feel. A capable host, aggressive caching and a CDN are the three levers that move it the most - which is why fixing TTFB is usually the highest-leverage performance work you can do before touching a single line of front-end code.
FAQ
What is a good TTFB?
Google's guidance (web.dev) puts a good TTFB at 0.8 seconds or less and a poor one above 1.8 seconds, judged at the 75th percentile of real visits. TTFB is not a Core Web Vital itself, but every millisecond of it delays Largest Contentful Paint, which is one. For a static or prerendered page served from a cache, a few tens of milliseconds is normal.
How do I measure TTFB from the command line?
With curl: curl -o /dev/null -s -w 'dns %{time_namelookup} tcp %{time_connect} tls %{time_appconnect} ttfb %{time_starttransfer}\n' https://example.com/ . The output splits the time into DNS lookup, TCP connection, end of the TLS handshake and first byte. On 22 November 2026, from our server to cdn.jsdelivr.net, this gave DNS 1.7 ms, TCP 4.8 ms, TLS finished at 28.8 ms and first byte at 33.6 ms: the server itself answered in under 5 ms, the rest was network and handshake. Subtract the TLS time from the TTFB to see how long the server spent working.
What does a connection timeout mean when measuring TTFB?
It means no first byte arrived before the tool's time limit, so there is no TTFB to report. Look at which step stopped: if TCP never connected, the server is down, a firewall drops the packets or DNS points to the wrong address. If the connection and TLS succeeded but nothing came back, the application is stuck (a slow database query, a saturated PHP or Node process, an upstream that does not answer). In curl, --connect-timeout limits the connection only and --max-time the whole request.
Will better hosting reduce my TTFB?
Only the server part of it. If your measurements show a large gap between the end of TLS and the first byte, typically several hundred milliseconds, the server is the cause: page caching, a closer region or a less crowded machine (a VPS rather than busy shared hosting) will shrink it. If most of the time is DNS and handshake, the fix is a CDN or a host nearer to your visitors, and a faster CPU changes nothing.



On the network side, [a CDN](/articles/what-is-a-cdn) shortens the physical distance between your server and each visitor, so the request and response travel less far. Modern connection handling - HTTP/2 or HTTP/3, keep-alive, and a well-configured TLS setup - reduces the handshake overhead, and where a page can be pre-rendered to static files, static hosting removes server processing from the critical path almost entirely.