skip to content

In the Chrome DevTools Timing tab for a request, what does each main phase mean and what does a long one point to?

level: middleimportance: must knowfreq 52%

answer

  1. before the connection, then during it
  2. six connections on HTTP/1.1
  3. a reused connection skips rows
  4. first byte versus last byte
  5. the server can report its own steps

basics

~20 s

Queueing and Stalled mean the browser held the request back; DNS lookup, Initial connection and SSL mean connection setup; Waiting for server response means server time plus a round trip; Content download means reading the body.

solid answer

~40 s

Click a row and open **Timing**. **Queueing** and **Stalled** are time the browser held the request back, for example behind higher-priority requests or at the six-connection limit per origin on HTTP/1.x. **DNS lookup**, **Initial connection** and **SSL** are connection setup, and they disappear on a reused connection, so a long one suggests a cold connection, distance or retries. **Request sent** is usually tiny unless the upload is large. **Waiting for server response**, which older guides call TTFB, is one round trip plus the server's work, so a long one points at the backend or the distance to it. **Content download** is reading the body, so it points at payload size or a slow link. The longest phase tells me which layer to investigate next.

go deeper

for a junior

Recall where the tab is and the rough order: browser waiting, connection setup, sending, waiting for the server, downloading the body. Knowing the current label, Waiting for server response, helps.

for a middle

Explain what each phase measures and which layer it blames, including why connection rows vanish on reuse and why Queueing depends on HTTP version. This is the tier the question is really asking for.

for a senior

Show judgment about what a phase does not prove: a long wait may be distance rather than code, a long download may be a busy browser. Reach for Server Timing to split the wait with evidence.

for a principal

Treat the breakdown as a shared language: a team whose APIs emit Server-Timing lets any engineer split a slow call without server access, which is a small backend cost for faster triage across teams.

## Where the breakdown lives The **Waterfall** column in the Chrome DevTools Network panel draws each request as a bar along a shared timeline. Hovering a bar previews its phases, and clicking the row and opening the **Timing** tab shows them as a table with durations. The tab also prints `Queued at` and `Started at` times. The **Time** column gives only the total; the Timing tab says where that total went. The point of the tab is diagnosis: each phase belongs to a different layer, so the longest phase tells you which layer to look at. The rows are grouped under headings such as **Resource scheduling**, **Connection start** and **Request/Response**. ## The phases, in order | Phase label | What is happening | A long one points to | |---|---|---| | **Queueing** | The browser holds the request before connection start | Many higher-priority requests, or the HTTP/1.x connection limit | | **Stalled** | The request waits after connection start, for the same reasons | The same causes as Queueing | | **Proxy negotiation** | Negotiating with a proxy server | A proxy on the path | | **DNS lookup** | Resolving the hostname to an address | A slow resolver or a first visit to that host | | **Initial connection** | TCP handshakes and retries, and negotiating SSL | Distance, packet retries or a cold connection | | **SSL** | The TLS part of connection setup | Handshake cost; it sits inside Initial connection, so do not add the two | | **Request sent** | Sending the request | A large upload on a slow link | | **Waiting for server response** | From sending to the first response byte | Backend work, or distance to the server | | **Content download** | Reading the response body | A large payload, a slow link or a busy browser | ## Reading the browser-side phases **Queueing** and **Stalled** are time spent before any byte of the request has gone out. Common reasons: - **Higher-priority requests** are ahead in line. - **The connection limit:** six TCP connections per origin are already open. That limit applies to HTTP/1.0 and HTTP/1.1, so a long Queueing on an HTTP/2 connection needs another explanation. The **Protocol** column shows which one was used. - **Disk cache allocation:** the browser is briefly reserving space in its cache. A long Queueing bar is a useful finding because the fix usually lies in how many requests the page makes and over which protocol, rather than in this endpoint's handler. ## Reading the connection phases **DNS lookup**, **Initial connection** and **SSL** only appear when the browser has to open a new connection. A request that reuses an open connection has no such rows, and this explains a common puzzle: the first call to an API host takes 400 ms longer than the second, and nothing about the endpoint changed. The optional **Connection ID** column shows which requests shared a connection. ## Reading the server and download phases **Waiting for server response** is the phase people ask about most. Older guides and many blog posts call it **Waiting (TTFB)**, for time to first byte, but the current label is the longer one. It includes one round trip of latency and the time the server took to prepare the response, so a long value does not by itself prove the code is slow; a distant server with a fast handler looks similar. If the server sends a `Server-Timing` response header, its metrics appear in a **Server Timing** section of the same tab. That is the cleanest way to split the wait into database, cache and application work without leaving the browser. **Content download** runs from the first byte to the last. Check it against the **Size** column: a large body on a modest link explains itself. A small body with a long download deserves more attention, because the phase can also grow when the browser is busy with other work and reads the response late. ## Traps when reading the table 1. Do not add SSL on top of Initial connection, since the bars overlap. 2. Do not compare a first request with a later one without checking connection reuse. 3. Watch for the note `Caution: Request isn’t finished yet`, which means the numbers are still changing. 4. If a service worker handles the request, expect extra rows such as **Startup**, **respondWith** and **Request to ServiceWorker**, which measure the worker rather than the network. These rules let you turn one row into one sentence: "this call spent 80% of its time waiting on the server, and the connection was already open", which is what the next person needs to know.

  • The second call to the same API host in Chrome DevTools has no DNS lookup or Initial connection rows. Is the Timing tab hiding them?
    No. Those phases only exist when a new connection is opened. The second call reused the open connection, so it had nothing to set up. That is why comparing a first request with a later one can look like an endpoint got faster when only the connection work disappeared. The Connection ID column confirms the reuse.
  • How can you tell server processing from network distance when Waiting for server response is long?
    The phase includes one round trip plus server work, so the Timing tab alone cannot split them. If the server sends a `Server-Timing` header, the tab's Server Timing section shows its own measured steps. Otherwise compare a trivial endpoint on the same host: a similar wait suggests distance, a much shorter one suggests the handler.
  • Why might HTTP/2 change what a long Queueing bar means?
    The six-connection limit behind much HTTP/1.x queueing does not apply to HTTP/2, which multiplexes requests over one connection. So on HTTP/2 a long Queueing bar needs another explanation, such as lower priority behind other requests. Check the Protocol column first, because a proxy or misconfigured server may have left the page on HTTP/1.1.

  • Calls every long request a slow backend without reading which phase is long.
  • Treats a long Queueing bar as proof that this endpoint's server code is slow.
  • Adds SSL to Initial connection and reports double the handshake time.
  • Says the six-connection limit applies on HTTP/2 connections as well.
  • Says Waiting for server response is purely server code, ignoring the round trip.
  • Compares a first call with a later one and ignores connection reuse.