← Back to Index

Time to First Byte (TTFB)

FigureBreakdown of TTFB components. It's not just "server processing"; DNS and Connection time count too.

What is TTFB?

Time to First Byte (TTFB) measures how long it takes from when a user's browser sends a request to when it receives the first byte of response from the server. It is a fundamental metric that indicates server responsiveness and network efficiency.

TTFB encompasses multiple stages of the request-response cycle:

  1. DNS Lookup — Resolving the domain name to an IP address
  2. TCP Connection — Establishing the network connection handshake
  3. SSL/TLS Handshake — Negotiating the secure connection (for HTTPS)
  4. Server Processing — The server executing code, querying databases, and generating the response
  5. Response Transmission — Sending the first byte back to the client

Each stage contributes to the total TTFB. While server processing often takes the longest, network latency and connection overhead can also significantly impact the metric.

Why TTFB Matters for SEO

1. Foundation of Page Speed

TTFB is the starting point for all other performance metrics. You cannot have a fast Largest Contentful Paint (LCP) or First Contentful Paint (FCP) if your TTFB is slow.

If your server takes 2 seconds just to start sending data, users have already waited 2 seconds staring at a blank white screen before any content loading even begins.

2. Core Web Vitals Connection

While TTFB is not directly a Core Web Vital, it significantly impacts those that are. A slow TTFB directly degrades:

  • LCP (Largest Contentful Paint) — Cannot render large content until data arrives
  • FCP (First Contentful Paint) — Cannot paint anything until HTML starts arriving
  • INP (Interaction to Next Paint) — Delayed page loading affects interactivity

Google considers page speed in rankings, and TTFB is a critical component of speed.

3. Crawl Efficiency

Slow TTFB affects how efficiently Googlebot can crawl your site. If every page takes seconds to respond, Google may reduce your crawl budget, leaving pages undiscovered or taking longer to index updates.

4. User Experience and Bounce Rate

Users expect near-instant responses. Studies show that delays beyond 100ms are noticeable, and delays beyond 1 second feel slow. High TTFB leads to:

  • Increased bounce rates before content even loads
  • Lower engagement and conversions
  • Negative perception of your brand

TTFB Benchmarks

Google's recommendations for TTFB:

  • Good: Less than 200ms
  • Needs Improvement: 200ms to 600ms
  • Poor: Greater than 600ms

These benchmarks represent the 75th percentile of page loads — meaning 75% of visitors should experience TTFB within these thresholds.

For competitive SEO, aim for under 200ms when possible. Every 100ms improvement in TTFB contributes to better overall performance metrics.

What Affects TTFB

Server-Side Factors

  • Application code efficiency — Slow algorithms or redundant processing
  • Database queries — Unoptimized queries or missing indexes
  • Server resources — CPU, memory, and disk I/O limitations
  • Server software — Web server configuration and version
  • Language/framework — Some runtime environments are slower than others

Network Factors

  • Geographic distance — Physical distance between server and user
  • Network routing — How packets travel across the internet
  • DNS resolution — Time to look up your domain's IP address
  • Connection overhead — TCP and TLS handshake time

Third-Party Factors

  • Hosting quality — Shared hosting is typically slower than dedicated
  • CDN configuration — Whether content is cached at edge locations
  • External API calls — Waiting for third-party services during page generation

How to Improve TTFB

Server-Side Caching

Caching is the most effective TTFB optimization. Instead of regenerating pages for every request, serve cached copies:

  • Full-page caching — Store complete HTML responses
  • Object caching — Cache database queries and computed values
  • Redis/Memcached — In-memory caching for fast retrieval
  • Varnish — HTTP accelerator for caching at the web server level

Content Delivery Network (CDN)

CDNs like Cloudflare, Fastly, or AWS CloudFront serve content from servers geographically close to users:

  • Reduced network latency
  • Edge caching for static and dynamic content
  • Protection against traffic spikes
  • SSL termination at the edge

Database Optimization

Slow database queries are a common TTFB bottleneck:

  • Add indexes to frequently queried columns
  • Optimize slow queries identified in query logs
  • Use query caching where appropriate
  • Consider read replicas for high-traffic sites
  • Reduce N+1 query patterns

Static Site Generation

For content that does not change per-request, generate HTML at build time rather than runtime:

  • Next.js SSG/ISR — Static generation with incremental regeneration
  • Gatsby/Hugo/Jekyll — Traditional static site generators
  • Jamstack architecture — Pre-built pages served from CDN

Server and Runtime Updates

Newer versions of server software and programming languages often include significant performance improvements:

  • Update PHP, Node.js, Python, or Ruby to latest stable versions
  • Upgrade web servers (Nginx, Apache) and configure optimally
  • Use HTTP/2 or HTTP/3 for connection efficiency

DNS Optimization

Reduce DNS lookup time:

  • Use fast DNS providers (Cloudflare, Route 53)
  • Minimize DNS chain length
  • Implement DNS prefetching for critical domains

Measuring TTFB

Browser Developer Tools

Open Network tab in Chrome DevTools, load your page, and check the "Waiting (TTFB)" value in the request timing breakdown.

WebPageTest

WebPageTest provides detailed TTFB measurements from multiple global locations, showing geographic variation in server response times.

Google PageSpeed Insights

PageSpeed Insights shows TTFB as part of its performance audit, with recommendations for improvement.

Synthetic vs Real User Monitoring

  • Synthetic — Controlled tests from specific locations (WebPageTest, Lighthouse)
  • RUM (Real User Monitoring) — Actual user data from your analytics

Both perspectives are valuable. Synthetic testing isolates variables, while RUM shows real-world performance.

TTFB Troubleshooting

If TTFB is slow, diagnose by isolating components:

  1. Test from the server itself — If fast locally, the problem is network-related
  2. Test without application code — A simple HTML file reveals server baseline
  3. Check database independently — Query times from database tools
  4. Compare cached vs uncached — Shows caching effectiveness
  5. Test from multiple locations — Geographic patterns indicate CDN issues