WebTech1223411 logo WebTech1223411Web tech, read closely
Browsers

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.

A browser network panel waterfall showing six requests in flight and the remaining rows waiting with long queueing bars

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.

ProtocolConnections per originRequests in flightWhat still blocks
HTTP/1.166The browser queue, one response per socket
HTTP/21Usually 100 to 128TCP packet loss stalls every stream
HTTP/3 over QUIC1 UDP flowUsually 100 or moreLittle, 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.

MC
Maren Castellanos

Maren worked in cross-browser QA before editing, and knows the DevTools Network tab better than most people know their inbox. She writes about how browsers load and render pages and about the tools that show what is really happening.

More posts by Maren

More in Browsers

01doorganico 084goad 3hot8 4465456 after5internprogram ahandfulofblessings ahmadpc ahomcybersecurity allodialresources annodex antiquesandperiodcollectibles aotc asianworldkashmir beedlectrics bloggertemplatefree bluefeatheragency bodyweightsolution campaign08blog carfixadvisor catstreetcollective cbstvsports cnfanspurchasing committeeof500yearsofdignityandresistance covertopsdjs cs-kaiyuangame cuestacomunicaciontotal cxoutlet dancebetgame deskgearhub destinyvillastay detectmagazine di33 diamondsteelbuildings donmo dyanadropship emarsysfinance emimattl escapechan eskitarih evautoplay everythingweddings-orlando farmzone feedviewerapp foxstudiosscratch gamevui123 gleasongrade greetingsday hacklabasu haskell iw-kaiyun jagoanproperti jilidskripsi joltbusinessfinance juegodepokergratis juegospucca kaeru-festival latestmehndidesigns lestanzediottaviano litemagazines localcommunityhero lustrsazan mariashebets menswheels newwebstechs1 nikkit ootheday oxigenvpn plurfitness prefetial probudgetcarpetcleaning psychicmrsmartin pyaten qvantor rejoignezlogis rexzbot riselayouts ruchin rwxqsgd5 sakaltime shibiaowang shop-bot skrtips spotlesshaven strcoding tetapatrium topselller uneplanteartificielle vipertechcr wo-kygaming yamaha-mekar yeknava yoybuysheets zenunwa yamaha-mekar jilidskripsi ankertoto ankertoto ankertoto