What Is Network Server Latency?

Saar Twito10 min read
Saar Twito
Saar TwitoFounder & SEO Engineer

Hi, I'm Saar - a software engineer, SEO specialist, and lecturer who loves building tools and teaching tech.

View author profile →

What Is Network Server Latency?#

Network server latency is the time a server spends between receiving a request and starting to send the response: the work it does, such as running code, querying a database and calling other services, apart from the time the network takes to carry the request and the answer. Together with the network round trips, it makes up Time to First Byte.

Key Facts (TL;DR)

  • No official pass mark. Lighthouse's Server Backend Latencies audit is informative: it lists an estimate for every origin the page loaded from and reports a score of 1 whatever the values.
  • Greadme's warning threshold is 50 ms per origin. It is a product guideline, chosen where the formula in Lighthouse's own source would fall below 0.9, not a Lighthouse pass or fail; Greadme marks an origin poor above 250 ms.
  • It is an estimate from one lab run. The figure for each origin is a lab-test estimate taken from the test environment, so treat it as a lead to investigate, not necessarily a measurement of what your visitors experience.
  • Third-party origins count too. A slow analytics or widget server shows up in the same table, and the fix there is to load it later or drop it, not to tune your own back end.
  • The usual causes on your own server are uncached rendering, slow or repeated database queries, calls to other services made one after another, and cold starts.

Is There an Official "Good" Server Latency?#

No, and the number often quoted as one needs explaining. Lighthouse's network-server-latency audit computes a score of 1 − slowest latency ÷ 500 ms in its source, which would be 0.9 at 50 ms and 0.5 at 250 ms. But the audit is declared informative, and Lighthouse's audit.js replaces the score of every informative audit with 1. So the report shows the latencies with no pass or fail, and that formula is never applied to your page.

Greadme needed a level at which to point an origin out and offer an AI fix prompt, and took 50 ms, where that formula drops below 0.9, the score Lighthouse treats as good elsewhere. Above 250 ms, where it would drop below 0.5, Greadme marks the origin poor. Both are Greadme's own guidelines built on Lighthouse's scale, not standards: a server that takes 80 ms on one lab run may be fine, and one that takes 30 ms may still be worth caching if the page depends on it.

Greadme's warning bands for server latencyGreadme Page Audit's own bands per origin, on the scale of the formula in Lighthouse's source. Lighthouse itself reports this audit as informative, with a score of 1 whatever the latency.

Source: Greadme Page Audit's thresholds; Lighthouse core/audits/network-server-latency.js (score = 1 − max latency ÷ 500 ms) and core/audits/audit.js (informative audits score 1), read 2026-10-24.

How the Lab Test Estimates It#

A lab test can't see inside your server, so the number is worked out from the outside. For each origin, Lighthouse's network analysis uses a server response time recorded with the request when there is one; otherwise it takes the time from sending a request to receiving the response headers and subtracts the estimated round trip to that origin. It then reports the median over that origin's requests. That has three consequences:

  • It is per origin, not per page. Your HTML, your API, your image host and every third-party script each get their own row.
  • It is one sample. One lab test at one moment from the test environment: a cache that happened to be cold, or a busy minute, shows up as it was.
  • It depends on the round-trip estimate. If the round trip is overestimated, the server latency comes out lower, and the reverse. See our guide to network round trip time.

Server Latency, RTT and TTFB#

web.dev defines Time to First Byte as the sum of redirect time, service worker startup time, DNS lookup, connection and TLS negotiation, and the request up to the arrival of the first byte. Server latency sits in that last phase, together with the round trip that carries the request and the reply. web.dev's rough guide is a TTFB of 0.8 seconds or less, measured on real visits.

AspectNetwork round trip (RTT)Server latency
What it isThe time data takes to reach the server and come backThe time the server takes before it starts answering
Set mainly byDistance and the network routeWhat the server does for the request
Typical fixesA CDN, a closer hosting region, fewer round trips per connectionCaching, faster queries, parallel calls, warm instances
In Greadme Page AuditThe Network Round Trip Times cardThe Server Backend Latencies card

What Your Server Is Actually Doing#

Server latency is the sum of everything that runs after the request arrives and before the first byte leaves:

  1. Routing: the server or framework decides which handler responds.
  2. Cold start, if there is one: a serverless function or container that hasn't served traffic recently has to start its runtime and your code first.
  3. Authentication: reading the session, validating a token, loading the user.
  4. Database queries: often the largest step on dynamic pages, especially when a query scans a table or runs once per item.
  5. Calls to other services: internal APIs, third-party APIs and remote caches, each with its own latency.
  6. Application logic and rendering: building the HTML or JSON. A server that streams its HTML can send the first bytes before rendering finishes.

Here is an illustrative breakdown for a slow product page. The numbers are made up for the example, but the pattern of steps that wait for each other is common:

Illustrative server-latency breakdown for a slow product page:

  Routing + auth:               25 ms
  Database query (product):    180 ms
  Database query (related):    140 ms
  Pricing API call:            120 ms
  Template rendering:           45 ms
  ──────────────────────────────────
  Server latency total:        510 ms   (poor on Greadme's scale)
Where 510 ms of server time goesEach step waits for the one before it; the two database queries and the pricing call are 440 ms of the total.
Routing + auth
Database query (product)
Database query (related)
Pricing API call
Template renderingfirst byte
View the data as a table
StepStartEnd
Routing + auth0 ms25 ms
Database query (product)25 ms205 ms
Database query (related)205 ms345 ms
Pricing API call345 ms465 ms
Template rendering465 ms510 ms

Source: worked example from this article.

In this example, running the related-items query and the pricing call alongside the product query, rather than after it, would leave the product query's 180 ms as the longest wait. Measure your own server before choosing a fix; the slowest step is not always the one you expect.

How to Measure Server Latency#

  • Greadme Page Audit lists every origin the page loaded from in its Server Backend Latencies card, with the lab test's estimate for each. Origins above 50 ms are highlighted, and the card then offers a Copy as Prompt button naming them and what to check. The same report shows the server response time the lab test observed for the page itself and, where the Chrome UX Report has enough visits, your real visitors' TTFB.
  • Chrome DevTools, Network panel, Timing tab: the Waiting (TTFB) phase is the browser "waiting for the first byte of a response". It comes after the connection is set up, so it covers the server's time plus the trip there and back.
  • Server access logs: nginx can log $request_time ("time elapsed between the first bytes were read from the client and the log write after the last bytes were sent"), and Apache %D ("the time taken to serve the request, in microseconds"). Both cover the whole request, including sending the response, not only the time to the first byte. Look at the slowest requests, not only the average.
  • Database statistics: PostgreSQL's pg_stat_statements tracks "planning and execution statistics of all SQL statements"; sort by total_exec_time to find the queries that cost the most overall. MySQL's slow query log does a similar job.
  • Application performance monitoring: in production, a tracing tool shows which routes, queries and outgoing calls take the time on each request.
  • Greadme Site Audit crawls up to 1,000 pages of your site, so you can pick one page per template to test with a Page Audit. The crawl itself checks SEO, images and page structure, not speed.

9 Ways to Reduce Server Latency#

1. Cache What Doesn't Change per Request

The fastest work is work the server doesn't repeat. Cache rendered pages or fragments that are the same for everyone, and cache query results that many requests share, with an expiry that matches how fresh they need to be. Per-user data can be cached too, keyed by user and with a short lifetime.

2. Index the Columns Your Queries Filter On

Without a suitable index, the database reads the whole table to find matching rows, and that gets slower as the table grows. Ask the database how it runs the query, then add the index it is missing.

-- PostgreSQL: see how the query actually runs
EXPLAIN ANALYZE SELECT * FROM orders
  WHERE user_id = 42 AND status = 'paid';

-- If it scans the whole table, add an index for the filter
CREATE INDEX idx_orders_user_status
  ON orders (user_id, status);

3. Eliminate N+1 Queries

An N+1 pattern fetches a list and then runs one more query per item for related data: 50 products with an author each become 51 queries, each with its own trip to the database. Load the related data in one query instead.

Fix: use your ORM's eager loading, such as includes in Rails, select_related or prefetch_related in Django, or populate in Mongoose, and check the query log for queries repeated in a loop.

4. Make Independent Calls in Parallel

Three calls that don't depend on each other take as long as all three added up when made one after another, and about as long as the slowest one when made together.

// One after another: the waits add up
const user = await fetchUser();
const orders = await fetchOrders();
const recs = await fetchRecommendations();

// Together: the wait is about the slowest call
const [user, orders, recs] = await Promise.all([
  fetchUser(),
  fetchOrders(),
  fetchRecommendations(),
]);

5. Put Timeouts on Calls You Don't Control

A third-party service that is slow now and then makes your response slow by the same amount, unless the call has a timeout and a fallback.

// Race the call against a timeout, and fall back to nothing
const recs = await Promise.race([
  fetchRecommendations(),
  new Promise((_, reject) =>
    setTimeout(() => reject(new Error('timeout')), 200)
  ),
]).catch(() => []);

6. Keep Latency-Critical Routes Warm

A cold start adds the time to start a serverless function or container before it can handle the request, and it falls on the first visitor after a quiet period. Most serverless platforms let you keep a minimum number of instances ready; for routes where latency matters, use that, or an always-on service.

7. Render Static Where You Can, and Mind the Distance to Your Data

A page built ahead of time and served from a cache needs almost no server work per request. For dynamic pages, running the code nearer the visitor shortens the network trip, but if that code still queries a database in one distant region, each query pays the long trip instead, so move or replicate the data the page needs, or cache it near the code.

8. Load-Test and Size for Your Peak

A server that is fast at low traffic can slow down sharply when CPU, memory or database connections run out. Load-test at your real peak and watch latency at the slow end, not only the average.

9. Catch Regressions Before They Ship

A slow query added in one change is easy to catch in review and hard to find after launch. Time a representative request in your test pipeline and fail the build when it exceeds a budget you set for that route.

Common Server-Latency Problems and Fixes#

Problem: A Slow Third-Party Origin in the Table

What's happening: the slow row is someone else's server, such as a chat widget, a tag manager or an embed.

Fix: you can't speed up their back end. Load the script after the main content, load it only when needed, or remove it if the page doesn't need it.

Problem: Your Own HTML Origin Is Slow

What's happening: the page is rendered on every request, and that rendering waits on queries or other services.

Fix: cache the HTML where it is the same for everyone, then profile the rest: queries first, calls made one after another next.

Problem: Slow Only Sometimes

What's happening: one audit shows a slow server and the next doesn't. A cold start, a cache that had just expired, or a busy moment can each do that.

Fix: check your server's own logs and monitoring for the slow end of response times before changing anything; one lab run is one sample.

FAQ#

What is a good server latency?

There is no official threshold. Lighthouse reports server latency as an informative audit, with no pass or fail. Greadme Page Audit flags an origin above 50 ms, where the formula in Lighthouse's source would drop below 0.9, and marks it poor above 250 ms. Both are Greadme's guidelines; what matters in the end is your TTFB and LCP for real visitors.

How is server latency different from TTFB?

TTFB covers everything from starting the navigation to the first byte: redirects, service worker startup, DNS, connection and TLS, and the request itself. Server latency is the server's share of that last step. Reducing TTFB can mean fixing the server, the network round trips, or redirects, depending on where the time goes. See our guide to server response time.

Why does Greadme show latency for servers I don't own?

Because the audit covers every origin the page loaded from. A slow third-party origin can still delay your page, but the fix is in how and when you load it, not in your back end.

Will a CDN fix server latency?

Only for responses it can serve from its cache. A CDN that caches your HTML can answer without asking your server at all. If it only caches images and scripts, every page request still goes back to your server.

Should I fix server latency before front-end performance?

Fix whichever takes the most time. Greadme Page Audit's LCP breakdown shows how much of the page's largest paint is the wait for the first byte; if that part is large, start with the server, and if most of the time is spent after the HTML arrives, start with the page itself.

Conclusion#

Server latency is the part of TTFB your own code and infrastructure decide, at least for your own origins. There is no official pass mark for it; Greadme flags origins above 50 ms as a guideline, using Lighthouse's scale. Cache what you can, make queries cheaper and calls parallel, keep critical routes warm, and check your own measurements before acting on one lab run.

Run Greadme Page Audit on your key pages to see the server latency of every origin they load from, with a copy-ready prompt for any origin above the threshold.