Written with help from an AI assistant for research and editing; the commands were run and checked by hand, and the opinions are ours.
"Your site is slow" is not a diagnosis. Most of the time the number behind it is some flavor of response time, and response time on its own is too vague to fix anything. The first question is always the same: which metric, measured where, from which request?
The metric that usually hides behind the phrase is Time to First Byte. Google's TTFB article on web.dev defines it as the elapsed time between the start of a navigation and responseStart, the moment the first byte of the response begins to arrive. It includes redirects, service worker startup if there is one, DNS lookup, connection and TLS negotiation, and the request itself up to that first byte.
It does not include anything the browser does after that. Parsing, styles, images, scripts and painting all come later.
What does website response time actually measure?
It depends on the metric named in the report. If it's TTFB, it measures the trip to the first byte, connection steps included. It doesn't mean the page is loaded or that a visitor can use it.
That distinction matters because a small business site can have a perfectly fine first byte and still show a blank hero for two seconds while a large image and three scripts arrive. Or the reverse: a slow first byte from a cold server, then a light page that renders immediately.
How do I measure TTFB from the terminal?
curl can break a single request into phases with -w:
curl -s -o /dev/null -w ' dns %{time_namelookup} connect %{time_connect} tls %{time_appconnect} ttfb %{time_starttransfer} total %{time_total} ' https://example.com/ Every value is in seconds, measured from the start of the request, so they're cumulative, not separate durations. time_starttransfer is the closest curl gets to TTFB. To see how much of it is the server thinking rather than the network, subtract time_appconnect from time_starttransfer.
Add -L if the URL redirects. Without it, curl stops at the first response, and you'll be timing the redirect instead of the page. The web.dev definition counts redirect time as part of TTFB, so a chain of two redirects before the real page is worth knowing about.
Run it several times. One request is an anecdote: DNS caching, a CDN edge warming up or a busy connection can move it a lot.
for i in 1 2 3 4 5; do curl -s -o /dev/null -w '%{time_starttransfer}\n' https://example.com/ done How do I read it in the browser?
The browser gives you the same number for the navigation a real visitor makes. Paste this in the console on the page you care about:
const [nav] = performance.getEntriesByType('navigation'); console.log('TTFB (ms):', Math.round(nav.responseStart - nav.startTime)); web.dev's article shows the same approach with a PerformanceObserver, and the web-vitals library wraps it as onTTFB. The Network panel in DevTools shows the timing breakdown of the main document request, which helps tell waiting for the server apart from downloading the rest.
What does a visitor see while the page loads?
After the first byte, the browser reads the markup, requests styles, images and scripts, and paints what it can. A visitor may still be looking at a blank area or a partial layout, or at a page that looks ready and doesn't respond to a tap yet.
Core Web Vitals cover those parts: loading, interactivity and visual stability, as Google's Web Vitals overview explains. TTFB isn't one of them. web.dev says so directly and treats it as a diagnostic that sits in front of the loading metrics.
| What you notice | What to inspect first | The question it answers |
|---|---|---|
| The page takes a while to start | The main document request and its timing | Is the delay before the server replies, or somewhere else in the request? |
| The page starts but the main content appears late | The largest visible element and its image or font requests | Is a heavy asset or a render-blocking resource holding up what matters? |
| The page appears but feels hard to use | Whether links, menus and forms respond, and whether the layout jumps | Is the page ready for interaction and visually stable? |
Is there a "good" TTFB?
web.dev gives a rough guide: 0.8 seconds or less is good, more than 1.8 seconds is poor. It also says that because TTFB isn't a Core Web Vitals metric, sites don't strictly need to hit that threshold, as long as the slow first byte isn't keeping the loading metrics from being good.
So treat the number as a pointer. A TTFB of 1.4 seconds on a hosted builder is a question about the platform and the CDN, and often not one you can answer with your own code.
Which speed number should I trust?
One whose collection method you know. A lab test, like Lighthouse or a curl loop, describes a controlled run. Field data, which PageSpeed Insights shows when there's enough of it for the page or the site, reflects real visits. Neither label tells you what's wrong on its own. Connect the metric to what you saw on the page and to the change you're considering.
Can I compare my site with a competitor using one test?
One test is a clue. Pages differ in content, caching, location and network conditions. Compare equivalent pages under similar conditions, and use the result to form a question, not to declare a winner.
Does a fast first byte mean the whole page is fast?
No. Images, styles and scripts can still take a while to arrive or render, and the page may not respond to input yet.
What should I ask when a report says my site is slow?
Which page and which resource were measured, whether the metric is TTFB or a user experience metric, and whether it's lab or field data. Then ask what the evidence says to fix first. A useful answer names the delay and links it to a change you can verify.
If a speed report is pushing you or a client toward a rebuild, run the curl loop and the console snippet first. If you get numbers you can't explain, drop them in the comments with the platform you're on.
Originally published on Contento Solutions, where I write about SEO and AI visibility for service businesses.


