 |
During the early years of web application development, one of the most common problems that developers and webmasters faced was the limited number of simultaneous HTTP connections per domain. This constraint, imposed by browsers themselves, could cause noticeable slowdowns in page loading, especially on sites rich in resources such as images, style sheets (CSS), JavaScript files, fonts, and more.
The Connection Limit in HTTP/1.1
The HTTP/1.1 protocol, widely used until the mid-2010s, did not provide an efficient mechanism for handling multiple requests on a single connection. To avoid saturating the network or overloading servers, browsers limited 6 simultaneous connections per domain (in some cases even fewer). This meant that if a page required 50 resources to load (not uncommon on complex sites), many of them had to wait for previous connections to clear, slowing down the entire process.
 |
Strategies for Optimizing HTTP/1.1
To overcome these limitations, webmasters have developed some best practices that have become standard in web development:
1. File Concatenation
CSS and JavaScript files were consolidated into one or a few bundled files. This reduced the number of requests required. For example, instead of loading 10 separate JS files, a single bundle.js was created.
2. Minification
In addition to aggregation, files were minified (removing spaces, comments, and unnecessarily long variable names) to reduce the overall download size.
3. Sprite Images
In the case of images, especially icone and small repetitive graphics, the sprite technique was used: a single image containing all the necessary icons, from which specific portions were then displayed via CSS background-position. This drastically reduced the number of HTTP requests.
4. Domain Sharding
Some sites split resources across multiple subdomains (e.g., cdn1.site.com, cdn2.site.com) to artificially increase the number of concurrent connections, circumventing the per-domain limit.
The Arrival of HTTP/2 and the Multiplexing Revolution
With the introduction of HTTP/2, approved in 2015, many of these manual optimizations have become obsolescent. HTTP/2 introduced a number of significant technical improvements, the most important of which is multiplexing: the ability to handle multiple requests and responses simultaneously over a single TCP connection.
 |
Main advantages of HTTP/2:
-
One connection for multiple resources
-
Server Push, which allows the server to proactively push resources to the client.
-
Header Compression, which reduces the amount of duplicate data in headers.
-
Request Prioritization, for more efficient loading.
Thanks to these features, Modern sites can return to a modular structure of their resources (multiple separate, reusable files) without paying the price in performance.
Best Practices Today (with HTTP/2 and HTTP/3)
While HTTP/2 (and HTTP/3, which uses the QUIC protocol) has solved many of the connection management issues, performance is not automatically guaranteed. Some modern best practices include:
✅ Balanced modularity
With HTTP/2, you no longer need to concatenate everything into a single file. It's acceptable (and in some cases preferable) to split resources into smaller, reusable files, maintaining a good tradeoff between modularity and the number of requests.
✅ Lazy Loading and Code Splitting
Modern techniques such as code splitting in JavaScript (using tools like Webpack or Vite) allow you to load only the code needed for the current page, improving loading times.perceived performance.
✅ Intelligent caching
Good cache management via HTTP headers (Cache-Control, ETag) is essential to avoid repeated downloads of static resources.
✅ Using CDN
Content Delivery Networks distribute content to servers geographically close to the user, reducing latency and improving the browsing experience.
✅ Image Optimization
Today, modern formats such as WebP or AVIF are used, and techniques such as lazy loading are adopted to avoid loading images off-screen immediately.
Conclusion
HTTP connection management is a great example of how web technologies have evolved to solve structural problems and improve the user experience. Where once we fought against the six-connection limit per domain with creative solutions like sprites and file concatenation, today we can rely on advanced protocols like HTTP/2 and HTTP/3. However, performance remains the responsibility of developers, who must continue to follow up-to-date best practices to ensure fast, scalable, and accessible sites.
Follow me #techelopment
Official site: www.techelopment.it
facebook: Techelopment
instagram: @techelopment
X: techelopment
Bluesky: @techelopment
whatsapp: Techelopment
youtube: @techelopment
