What is TTFB (Time to First Byte)?
TTFB stands for Time to First Byte. It’s the time between the moment your browser sends a request to your website and the moment the very first byte of data comes back from the server. In other words: how fast does the web server respond to an incoming request?
TTFB consists of a few parts:
- Request sending: the time needed to send your HTTP request from the browser to the server. This depends on factors like the user’s network speed, the distance to the server, and DNS lookup time.
- Server processing: the time the server needs to process the request and generate a response (page). This includes starting PHP processes, running database queries, and loading required data.
- Sending the first byte: the time it takes to send the first byte of the server response to the browser. This is often short, but can be delayed by network conditions or server upload speed.
In plain terms, TTFB is the waiting time before your site starts loading. It’s not the full load time, but an indicator of server response speed. The shorter the TTFB, the faster the first piece of information arrives and the quicker the rest of the page can follow.
How can you measure TTFB?
You don’t need a stopwatch — several tools measure TTFB for you. Google PageSpeed Insights provides an indicator of server response time (where TTFB is a component) and will show a warning such as “Reduce initial server response time” when it’s slow. In most performance tools (for example GTmetrix, Pingdom, or WebPageTest) you’ll see TTFB in the waterfall chart, often labeled “Wait” or “TTFB” next to the first HTTP request. You can also check it in your browser’s developer tools (Network tab in Chrome or Firefox) by looking at the timing for the first response.
It’s important to realize that TTFB can vary per measurement, depending on where and how the test is run. A test from a server in the US will produce a higher TTFB for a site hosted in the Netherlands simply due to physical distance, while a local test from the Netherlands will show a lower value. That’s why it helps to view TTFB not as a single number but as trends and average user experience.
What counts as a “high” TTFB?
When is a TTFB too high? There’s no hard cutoff, but there are guidelines. Some indicative ranges:
- Excellent (< ~200 ms): The server responds very quickly. Google recommends staying under about 200 milliseconds for the best experience.
- Average (±300–500 ms): Many WordPress sites fall into this range. It’s not blazing fast, but not exceptionally slow either. For a dynamic site, this is often acceptable.
- Slow (> ~600 ms): Above half a second, it starts to feel slow. At ~600 ms or more, tools like PageSpeed Insights will warn that server response should be improved. A TTFB heading toward 1 second or higher is clearly a bottleneck that needs attention.
These are general guidelines. A large WooCommerce store or a site with lots of dynamic content can have higher TTFB simply because the server has more work to do on each request. Conversely, a simple static site or a well-cached page can achieve extremely low TTFB. Always interpret TTFB in the context of your site: treat it as a signal that there may be server-response delay users can feel.
What can cause a high TTFB?
If your TTFB is on the high side, what could be behind it? Common causes include:
- Your hosting and server power: The quality and configuration of your hosting has a big impact. On shared hosting (shared servers) where many sites compete for the same resources, higher TTFB values are common. A small server that’s overloaded or running outdated software (for example an old PHP version) will respond more slowly. A VPS or managed hosting can perform better, but if it’s not well optimized or is running at full capacity, TTFB will rise.
- No caching (dynamic pages): WordPress generates pages dynamically via PHP and database queries. If every visitor has to generate the page live, it costs time on each load. Without caching (like a page cache plugin or server-side caching), the server must redo all calculations for every visitor, which increases TTFB significantly. With caching, WordPress can serve a static version of the page, so the server does less work and the first byte reaches the visitor faster.
- Heavy plugins or themes: Not all WordPress sites are equal. If you run a full WooCommerce store, a page builder like Elementor or Divi, or many plugins that perform complex tasks, the server must do more per page load. A store, for example, runs queries for products and cart contents. A page-builder theme may build huge amounts of content and code. This translates into longer server processing time and thus a higher TTFB, especially without optimizations.
- Traffic spikes and load: If your site suddenly gets very busy (for example during a marketing campaign or seasonal peak), the server can respond more slowly under load. Many concurrent requests mean each request waits longer. The same applies to heavy background tasks (like backups or imports) — the server is temporarily less responsive for normal visitors.
- Network and distance: Sometimes it’s not WordPress or the server itself but the distance between the user and the server. If your hosting is in Europe and a visitor views the site from Asia or the US, the physical travel time for data is longer, which increases measured TTFB. DNS resolution or redirects can also add a small delay before the first byte. A CDN (Content Delivery Network) can reduce this by serving content closer to the user, but it’s important to remember that not every “high TTFB” means your server is bad — sometimes distance is the factor.
TTFB and Core Web Vitals (LCP and other metrics)
You may have heard of Core Web Vitals, the metrics Google uses to assess website user experience (including Largest Contentful Paint (LCP), First Input Delay (FID), and Cumulative Layout Shift (CLS)). Interestingly, TTFB is not one of the official core metrics. Still, TTFB strongly affects those other metrics.
Consider Largest Contentful Paint (LCP): it measures how long it takes for the largest content element to become visible. If your server takes 800 milliseconds to deliver the first byte, LCP can’t be lower than ~0.8 seconds plus the extra time to load the content. In other words, a slow TTFB pushes all subsequent timings upward. First Contentful Paint (FCP) — the moment the first content appears — is also directly delayed by a high TTFB, because the browser can’t show anything until that first byte arrives.
Google’s Page Experience update uses LCP as a ranking factor in search results. Indirectly, that means a high TTFB (which worsens LCP) can harm SEO. Google recommends keeping server response time under ~0.6 s to enable good FCP/LCP. That’s why PageSpeed Insights recommends improving “Initial server response time” when TTFB is too slow.
TTFB as a diagnostic signal
I always recommend seeing TTFB as a diagnostic signal, not as a goal to chase at all costs. In short: a low TTFB is nice, but what matters most is how quickly users can actually see and use content.
For example, you might have optimized the front end well (compressed images, minified CSS/JS, etc.) but the site still feels slow. Check TTFB: if it’s high, that points to delays on the server side (for example slow database queries or insufficient server capacity). In that case it makes sense to improve server optimization or hosting configuration. On the other hand, if your TTFB is low (say around 200 ms) but the page still takes 3 seconds to fully load because of huge images or heavy scripts, then the bottleneck isn’t the server response. In that case, pushing TTFB even lower won’t help much — you should focus on what happens after the first byte.
In other words: use TTFB as a clue. A high TTFB usually means something behind the scenes in your WordPress site needs attention (hosting, queries, caching). A low TTFB means the baseline is good, but it doesn’t guarantee a fast site — the elements that follow still need to load quickly. TTFB is just one part of overall website performance, and it should be balanced with the other factors.
Summary
In short: Time to First Byte (TTFB) measures how quickly your server sends the first byte to the browser. A high TTFB indicates a slow server response, which negatively affects page load time and impacts metrics like LCP. Factors such as your hosting choice, lack of caching, plugin weight, and traffic can significantly affect TTFB. Treat TTFB as a useful signal: if it’s high, it suggests server- or backend-side optimizations may be needed. Ultimately you want a fast overall user experience — a low TTFB helps, but it’s only one part of the whole picture.