Server response time is the amount of time it takes for a web server to respond to a browser request, measured as Time to First Byte (TTFB). It includes redirect duration, TCP/TLS connection time, and backend processing. Google recommends keeping TTFB under 200 ms. Everything else — HTML parsing, CSS rendering, images — waits until this first byte arrives.
Every millisecond of server delay pushes back Largest Contentful Paint, increases bounce rate, and compounds into lost rankings. TTFB is the foundation — fix it first before optimizing anything else on the page.
What is server response time?
Server response time measures how long a server takes to send the first byte of data back to a browser after receiving a request. The browser cannot parse HTML, load CSS, or request images until this first byte arrives — making TTFB the upstream bottleneck for every subsequent performance metric.
TTFB is composed of three sequential phases:
- Redirect duration — time spent following HTTP redirects before reaching the final URL
- Connection duration — time to complete TCP handshake and TLS negotiation
- Backend duration — time for the server to process the request, query the database, and generate the response
The formula: TTFB = Redirect time + Connection time + Backend processing time
Google PageSpeed Insights flags TTFB above 600 ms as a failing score. Google's own documentation recommends under 200 ms as the threshold for excellent server response time. TTFB above 800 ms correlates strongly with LCP failures, a confirmed Core Web Vitals ranking factor.
Why server response time matters for SEO
TTFB sits at the top of the page load waterfall. Every other metric — LCP, FCP, TBT — depends on a fast first byte. Three reasons this matters in practice:
- Core Web Vitals dependency. Largest Contentful Paint cannot be fast if TTFB is slow. A 600 ms TTFB leaves only 1,900 ms to load and render the LCP element before crossing Google's 2,500 ms "good" threshold — extremely difficult at scale.
- User abandonment. Every 100 ms of added latency increases abandonment probability before the page loads. For e-commerce, Amazon found a 100 ms delay reduces sales by 1%. That compounds across thousands of sessions.
- Crawl efficiency. Googlebot also waits for TTFB. Slow server response reduces how many pages Google can crawl per session, shrinking effective crawl budget for large sites.
What are the TTFB benchmarks?
Google PageSpeed Insights and industry tools use a consistent scale:
| TTFB Range | Rating | PageSpeed colour | Action |
|---|---|---|---|
| Under 200 ms | Excellent | Green | Maintain |
| 200–500 ms | Good | Green | Monitor |
| 500–800 ms | Needs improvement | Orange | Prioritise fixes |
| Over 800 ms | Poor | Red | Urgent action |
How server response time is measured
TTFB is measured in milliseconds from the moment the browser sends the HTTP request to when the first byte of the response body is received. Most performance tools expose TTFB in their waterfall charts as the "waiting" phase of the first document request.
curl -o /dev/null -s -w "TTFB: %{time_starttransfer}s\n" https://example.com/
# Output example
TTFB: 0.183s # 183 ms — within excellent range
What causes slow server response time?
Diagnosing TTFB means isolating which of the three phases is slow. The most common culprits:
- Shared hosting — CPU and memory shared across hundreds of sites; any spike on a neighbour slows yours
- Unoptimised databases — slow queries, missing indexes, or bloated revisions/spam tables add hundreds of milliseconds per page request
- No caching — dynamic pages generated fresh for every visitor, even when content hasn't changed
- Heavy plugins or modules — each plugin adding PHP or Node processing overhead to every request
- Geographic distance — origin server in the US serving users in Asia adds 150-200 ms of network latency alone
- DNS resolution delays — slow DNS providers add 50-100 ms before any connection begins
- Redirect chains — each extra redirect adds a full round-trip before the final response starts
How to improve server response time
The fastest wins come from caching and hosting upgrades. Work down this list by impact:
- Upgrade hosting. Move from shared to VPS, dedicated, or managed cloud. The jump from shared to VPS hosting typically cuts TTFB by 200-400 ms instantly.
- Implement server-side caching. Cache rendered HTML at the CDN edge or with a page cache plugin. Pre-cached pages return in under 50 ms regardless of server power.
- Use a CDN. Serve content from edge nodes close to users. A CDN alone can cut TTFB by 50-70% for international visitors.
- Optimise the database. Add indexes to frequently queried columns, remove unused plugins, clean up post revisions. A database audit often recovers 100-300 ms.
- Enable HTTP/2 or HTTP/3. Multiplexed connections eliminate the head-of-line blocking that slows HTTP/1.1 requests.
- Enable compression. Gzip or Brotli compression reduces response body size and transfer time, particularly for large HTML pages.
- Minimise redirects. Every redirect hop adds a round-trip. Use direct URLs wherever possible. Redirect to the final destination in one hop.
Teams often spend weeks compressing images and deferring scripts while ignoring a 900 ms TTFB. Images cannot load until the first byte arrives. Fix TTFB first — it's the multiplier that makes every other optimisation more effective.
Tools to measure server response time
| Tool | Best for | Cost |
|---|---|---|
| Google PageSpeed Insights | TTFB score + LCP correlation | Free |
| WebPageTest | Waterfall analysis + geographic testing | Free |
| GTmetrix | Historical TTFB trend tracking | Free / Paid |
| Chrome DevTools Network | Real-time debugging | Free |
| curl | CLI TTFB measurement | Free |
| New Relic / Datadog | Continuous production monitoring | Paid |
Server response time vs page load time — what's the difference?
TTFB and page load time measure different phases. Understanding the distinction prevents misdiagnosing performance problems.
Server response time (TTFB)
- Measures server-side performance only
- Controlled by hosting, caching, database
- Typically 50-800 ms range
- Fix by upgrading infrastructure
- Google target: under 200 ms
Page load time (LCP / TTI)
- Measures full browser render pipeline
- Controlled by assets, scripts, images
- Typically 1,000-5,000 ms range
- Fix by optimising front-end assets
- Google LCP target: under 2,500 ms
6 best practices for server response time
- Set a TTFB budget under 200 ms for all primary landing pages — not just the homepage.
- Cache at every layer — CDN edge, object cache (Redis/Memcached), page cache, and opcode cache (OPcache for PHP).
- Monitor from multiple geographic locations. A UK server may score 90 ms in Europe but 400 ms in Asia. Use WebPageTest's multi-region tests.
- Test under load. TTFB during a 10-user test means nothing at 1,000 concurrent users. Use k6 or Loader.io to simulate realistic traffic.
- Audit redirects regularly. Redirect chains accumulate over time. Run a crawl quarterly and collapse multi-hop chains to single hops.
- Review after every major plugin or dependency update. A single bloated plugin can add 200 ms to every request without any other code change.
Common server response time mistakes to avoid
- Testing only from one location — TTFB varies by 200-400 ms depending on user geography
- Ignoring database optimisation — slow queries are the most common cause of high backend time
- Not caching authenticated pages — logged-in users hit uncached pages and see full backend time on every load
- Using a CDN without origin caching — cache misses still hit the slow origin server, defeating the purpose
- Relying on PageSpeed alone — lab data; use CrUX (real user data) to confirm actual TTFB for your visitors
Frequently asked questions
Yes. TTFB (Time to First Byte) is the standard measurement of server response time. It captures the full duration from the browser's request to the arrival of the first response byte, including redirect time, connection time, and backend processing.
Google recommends TTFB under 200 ms for the best user experience. For competitive SEO and e-commerce, aim for under 100 ms. TTFB above 800 ms is considered poor and makes achieving good LCP scores nearly impossible.
Yes. CDNs cache content at edge locations geographically close to users, reducing network latency significantly. A CDN can reduce TTFB by 50-70% for international visitors by serving from the nearest edge node rather than the origin server.
TTFB is not a standalone ranking signal, but it directly influences Largest Contentful Paint (LCP), which is a confirmed Core Web Vitals ranking factor. Slow TTFB makes it nearly impossible to achieve good LCP scores, indirectly harming rankings.
Common causes include underpowered shared hosting, unoptimised databases with slow queries, missing caching layers, heavy plugins adding processing overhead, high traffic without auto-scaling, and geographic distance between the user and origin server.
