How Browsers Limit Connections and Queue Your Requests
Open the Network panel on a page that loads 40 images and you will see a shape that looks like a staircase. The first handful of requests start immediately.

Open the Network panel on a page that loads 40 images and you will see a shape that looks like a staircase. The first handful of requests start immediately. The rest sit with a long grey or pale bar at the front of their row, doing nothing, until a slot opens. The server is not slow and the images are not large. The browser is simply refusing to ask for more than a few things at once from the same origin.
I have watched developers spend an afternoon optimising a 40 KB image while the real cost sat in that queue, 900 ms of waiting that no amount of compression touches. The rule causing it is old, mostly sensible, and changed in an important way by HTTP/2. Knowing which one your site is on decides whether half the standard performance advice still applies or actively hurts you.
Where the six comes from
Under HTTP/1.1 a connection carries one request at a time. The response has to finish before the next request can go down the same socket. To get any parallelism at all, the browser opens several connections to the same origin, and to avoid hammering servers it caps how many.
That cap settled on six per origin across Chrome, Firefox, Safari and Edge, and it has barely moved in fifteen years. Firefox still exposes it as network.http.max-persistent-connections-per-server with a default of 6. Chrome also enforces a global ceiling of 256 sockets in total, which only matters on pages pulling from many hosts at once.
Origin is the key word, and it means scheme, host and port together. So this site and an image subdomain such as img.webtech1223411.site would get six each, and the https and the plain http version of one host count as two separate origins. That detail is what domain sharding was built on, and I will come back to why it backfires now.
If you want the full sequence that happens before any of this, our walkthrough of what happens between typing a URL and seeing a page covers the earlier stages.
What HTTP/2 changed, and what it did not
HTTP/2 multiplexes. One TCP connection carries many requests and responses at the same time, split into interleaved frames, so the six connection workaround became unnecessary. The browser opens a single connection per origin and sends everything over it.
The concurrency limit does not disappear, it moves. The server advertises SETTINGS_MAX_CONCURRENT_STREAMS in its opening handshake, and the browser respects that number. Nginx defaults to 128, Apache to 100, and many CDNs sit in the same region. In practice that is high enough that you stop seeing a queue of image requests, which is why migrating a sharded site to HTTP/2 often produces a waterfall that looks completely different for no other reason.
| Protocol | Connections per origin | Requests in flight | What still blocks |
|---|---|---|---|
| HTTP/1.1 | 6 | 6 | The browser queue, one response per socket |
| HTTP/2 | 1 | Usually 100 to 128 | TCP packet loss stalls every stream |
| HTTP/3 over QUIC | 1 UDP flow | Usually 100 or more | Little, loss affects only the hit stream |
The remaining HTTP/2 weakness is worth understanding because it shows up as a mystery stall. All those streams share one TCP connection, and TCP delivers bytes in order. Lose one packet and every stream waits for the retransmission, even the ones whose data already arrived. On a clean office network you will never notice. On a train with 2 percent packet loss, a multiplexed page can feel worse than the old six connection version. HTTP/3 moves the transport to QUIC over UDP, where each stream is tracked separately, and that is the problem it exists to solve.
Why domain sharding is now the wrong move
Splitting assets across static1, static2 and static3 subdomains was genuinely good advice in 2012. Three origins, six connections each, eighteen images in flight instead of six. Plenty of older guides and a fair number of internal engineering docs still recommend it, and I keep meeting sites that are still doing it.
On HTTP/2 it is a net loss, for reasons that are easy to measure. Each extra hostname costs a DNS lookup, a TCP handshake and a TLS handshake before a single byte of image arrives. Throttle to Slow 4G in DevTools and that is routinely 300 to 500 ms per shard. You have also thrown away connection reuse, prioritisation across the whole page, and header compression state, all of which only work within one connection.
There is a wrinkle that makes this harder to spot. Browsers do connection coalescing: if two hostnames resolve to the same IP address and the TLS certificate covers both, Chrome and Firefox will quietly reuse the single existing connection for both. So a sharded site behind one CDN may already be acting unsharded, and your measurements of the shards will show no handshake cost at all. Change CDN config so the IPs differ, or use a certificate that does not cover every shard, and the cost reappears without anyone touching the HTML.
The one case where more than one origin still earns its keep is a genuinely different server with a different cache profile, such as a separate media host that you want on its own cache rules. That is one extra origin, chosen deliberately, not three mechanical shards.
Reading the queue in DevTools
Hover any request row in the Network panel and the Timing tab breaks the wait into named parts. Three of them get confused constantly.
- Queueing means the browser has decided not to send the request yet. The usual causes are a higher priority request holding the slot, the six per origin limit on HTTP/1.1, or the browser briefly allocating disk cache space.
- Stalled means the request is waiting on a connection, including proxy negotiation. Long stalls on HTTP/1.1 with many assets from one host are the classic connection limit signature.
- Initial connection covers the TCP handshake and TLS. Seeing this repeat for several hostnames in a row is the sharding cost made visible.
Add the Protocol column to the Network panel, which is off by default: right click any column header and tick it. Values of h2 or h3 tell you the request is multiplexed, http/1.1 tells you it is competing for one of six slots. I check this before anything else on a slow page, because the answer changes which fixes are worth trying.
One habit that saves time: sort by the Waterfall column and look at where the staircase steps. If the step width is roughly the response time of the slowest asset and the step height is six rows, you have found a connection limit and not a server problem.
What to change first
If the Protocol column says http/1.1, enabling HTTP/2 is the whole fix and almost everything else is a workaround for not having done it. It is a server or CDN setting, not a code change.
If you are already on h2, stop adding hostnames and start reducing what competes. Fewer, better prioritised requests beat more parallelism: inline the handful of critical styles, preload only what the first screen needs, and let images below the fold load lazily so they are not in the stream pool at all. Our guide to browser resource hints covers which hint does which job, and the rest of the browsers section goes through the surrounding stages of the load.
FAQ
How many requests can a browser make at once?
On HTTP/1.1, six per origin in every current desktop browser, with a global cap around 256 sockets in Chrome. On HTTP/2 it is one connection carrying roughly 100 to 128 concurrent streams.
Does domain sharding still help performance?
Not on HTTP/2 or HTTP/3. Each extra hostname adds DNS, TCP and TLS work and breaks connection reuse and prioritisation, which usually costs more than the parallelism gains.
Why do my requests show a long queueing time?
Either a higher priority request is holding the slot, the origin has hit its six connection limit, or the browser is reserving disk cache space. Check the Protocol column to tell the first two apart.
Is HTTP/3 worth enabling for this?
It helps most on lossy mobile networks, where one dropped packet no longer stalls every stream. On stable connections the difference against HTTP/2 is usually small.
More in Browsers
Browsers
How the Browser Preload Scanner Finds Resources Early
A team I helped last year had a hero image arriving 1.2 seconds into the load on a page whose HTML had finished downloading in...
Browsers
How CORS Preflight Requests Add an Extra Round Trip
A dashboard I was asked to look at last year loaded in 4.2 seconds against an API that answered every call in 30 ms.
Browsers
How Web Font Loading Works and How to Avoid Invisible Text
The page has loaded, the layout is there, but the headline and body text are blank for a second or two before they suddenly...