You click a link. A fraction of a second later, a page with text, images, and videos appears on your screen. It feels like magic, but it’s not. It's the work of a tireless messenger of the web: the Hypertext Transfer Protocol, or HTTP.

The story of HTTP isn't a neat timeline, it's a story of hitting walls, finding clever workarounds, and sometimes, throwing out the old rule book entirely.

HTTP / 0.9 - this is where it all began

To get a document from a server, you needed a protocol that was brutally simple.

HTTP/0.9 was exactly that. It was so simple it's almost stupidly funny by today's standards.

There were no headers. No metadata. No cookies.
There was only one method: GET.
The request was literally a single line: GET /some-page.html.

The server dumps the raw html (text-only) and the connection is lost.

HTTP / 1.0 - a better solution

The web couldn't stay a text-only club forever. It wanted pictures. It wanted different layouts and eventually more than http/0.9.

Version Numbers: Requests now said which "language" they were speaking (e.g., GET /my-cat.gif HTTP/1.0).
Status Codes: Finally, a standardized way for the server to say what happened. 200 OK meant success, 404 Not Found meant you were asking for something that wasn't there.
Headers: This was the big one. Now, both the request and the response could carry a little backpack of metadata. The Content-Type header meant we could serve images, CSS files, and more, not just HTML.

HTTP / 1.1 - the internet standard

By 1997, the web was exploding, and the connection issue with 1.0 was a serious bottleneck. HTTP/1.1 arrived to fix it, and it did such a good job.

Persistent Connections : The browser could now make one connection to the server and reuse it to ask for multiple things. This was a huge deal for performance.

It also introduced a feature called Pipelining. It let a browser send a bunch of requests at once without waiting for the answers but the problem was that the server had to send the responses back in the exact same order.

This led to a nasty problem called Head-of-Line (HOL) Blocking.

HTTP / 2.0 - speed was a game changer

By the 2010s, websites weren't just a few images and some text. They were complex applications with dozens, sometimes hundreds, of resources. HTTP/1.1, even with its persistent connections, was creaking under the strain. The Head-of-Line blocking was a real pain.

In 2015 after the launch of http/2.0, instead of plain text, it spoke binary—much faster for computers to process. But its true superpower was Multiplexing.

With multiplexing, the browser could fire off all its requests at once over a single TCP connection, and the server could send back the responses as soon as they were ready, in any order.

HTTPS / 3.0 - the underlying protocol got changed

HTTP/2 fixed HOL blocking at the application level, but the problem was still hiding one layer deeper, in TCP — the very foundation that the whole internet is built on.

TCP is obsessed with order. If a single data packet gets lost on its way across the internet, TCP panics and makes everyone wait until that lost packet is found and re-sent.
This means all of our beautifully multiplexed HTTP/2 streams would grind to a halt.

The solution in HTTP/3 is absolutely brilliant, it is to ditch TCP and adopt UDP.

HTTP/3 runs on a new protocol called QUIC, which is built on top of the much simpler UDP.
QUIC adds all the smarts—reliability, congestion control, and security—on top of it.

Because QUIC manages streams independently, if a packet from one stream gets lost, it only holds up that one stream. The others can just keep on flowing. It finally, truly, solves the Head-of-Line blocking problem, from top to bottom. It also makes establishing new connections much faster.

As we continue to build and expand the web, HTTP remains the backbone of our online experiences, evolving to meet the demands of an ever-changing digital landscape. Looking ahead, HTTP will keep evolving, ensuring the web stays fast, secure, and accessible for all.

The Protocol That Built the Web: A Slightly Messy History of HTTP