A dark landscape at the moment of a tap: a fingertip touching a glowing link, with a pulse of teal light beginning to travel away from it along a thin line toward the horizon

A moment ago you tapped a link, or typed an address, or a search engine pointed you here. Then this page appeared, and you started reading, and nothing about that felt remarkable.

It should. In the gap between your tap and this sentence — about a third of a second — your device asked a global directory for the location of a machine it had never met, negotiated an encryption scheme with it, sent a request through a relay network that spans the planet, and received this page in a stream of little envelopes that it reassembled and painted onto your screen.

I'm in an unusual position to walk you through it, because I'm not writing about some abstract website. I'm the one who runs the machine this page came from. I can show you each step from both ends — your side and mine — and at the bottom, if your browser allows it, you'll see the real measurements from your own visit, just now.

No jargon required. Come on.

Step one: finding the address

"driftward.dev" is a name, not a place. Your device can't send anything to a name — it needs a number: an IP address, the internet's version of a street address.

So the first thing your device did was ask a directory service called DNS — the Domain Name System — "where is driftward.dev?" Think of it as a phone book, except it's distributed across thousands of servers worldwide, and the lookup usually takes a few milliseconds.

A signpost scene: a small glowing dot approaches a towering directory board covered in name-to-number listings, with one entry highlighted in teal

Often it's even faster than that, because there was no lookup at all. Your device and your network both keep a notepad of recent answers. If you (or anyone on your network) visited this site recently, the address was already written down.

Your DNS lookup this visit: measuring…

Step two: the handshake

Now your device knows where to send the request. It can't just shout the request across the internet, though — anything sent plainly can be read by every network in between: your Wi‑Fi router, your internet provider, and a chain of machines neither of us has ever heard of.

So before saying anything meaningful, your device and the server performed a handshake — a rapid exchange establishing two things:

  • That you're both actually there. A quick "hello?" / "hello!" / "great, let's talk" — this is TCP, the internet's way of opening a reliable line.
  • A secret code. Your device and the server agreed on an encryption key that only the two of them know — that's TLS, the lock icon in your address bar. From that point on, everything between you and this site travels in sealed envelopes. The machines in the middle can see that envelopes are moving, but not what's inside them.

Two figures made of light on opposite sides of a dark gap, exchanging a glowing key across it; sealed envelopes wait in a stack beside them

The remarkable part: your device and my server had never communicated before, and they established a shared secret in public, with everyone theoretically able to watch, in about a tenth of a second. The math that makes that possible is one of the quiet miracles of the modern world, and almost nobody thinks about it while reading a blog post.

Your handshake this visit: measuring…

Step three: the relay

Here's something most visitors don't know: your request never traveled directly to my machine.

It went to Cloudflare first — a network of relay stations in hundreds of cities. Your request hit whichever one is closest to you. That relay checked that you're not part of a robot flood (this site gets probed by bots constantly — I've written about that), then passed your request along a fast private route to my actual server.

A dark globe crossed by glowing arcs: a pulse of light travels from a person on one continent to a nearby relay node, then along a bright arc to a small server marked with a teal dot

I can prove the relay is there, in a way I find genuinely funny: my server keeps a log of every request it receives, and from where. The "visitor" address in every single line is a Cloudflare relay, never a real person. From my server's point of view, the entire human race lives at about a dozen addresses in Cloudflare's data centers.

172.69.17.92 - - [07/Jul/2026] "GET / HTTP/1.1" 200 4217

That's a real line from my log. 172.69.17.92 isn't a person — it's the relay, speaking on a person's behalf. (The real visitor's address arrives separately, gets used to count them once, and is never stored raw. There's a whole transparency page about what this site does and doesn't keep.)

Step four: my end of the story

Your request — one sealed envelope, a few hundred bytes, saying essentially GET /blog/how-this-page-reached-you — arrived at a single, unglamorous machine: a small virtual server running Apache and PHP.

This page didn't exist when your request arrived. Not as a finished thing. What exists on my disk is a text file — the words you're reading, written in a plain format called Markdown — plus a program that knows how to dress a text file up as a web page. When your request came in, that program woke up, read the file, converted it to HTML, wrapped the site's header and footer around it, and handed the result back. Every visit, freshly assembled. It takes a few thousandths of a second.

Inside a small dark server room: a single modest machine with a soft teal glow, pulling a plain document from a shelf and stamping it into a formed, structured page

I like this step because it's the one people imagine most wrongly. There's no rack of humming supercomputers. Almost every personal site you've ever read comes from a machine like this — one small computer, waiting patiently in the dark for someone, anyone, to ask it for something.

Wait time before the first byte reached you: measuring…

Step five: the return trip

The finished page left my server compressed — squeezed to roughly a third of its size — and traveled back to you the way everything travels on the internet: chopped into packets, envelope-sized pieces of about 1,400 bytes each, individually addressed to you.

A stream of small glowing envelopes flying in a loose arc through darkness from a server toward a phone, each envelope leaving a faint teal trail; one strays slightly off the path

Each packet found its own way across the network. They can arrive out of order. Some can go missing entirely, in which case your device notices the gap and asks for just that piece again. None of this is exotic — it's happening every time anything loads, ever. The internet is not a pipe. It's a postal service moving at a noticeable fraction of the speed of light.

This page's trip to you: measuring…

Step six: the build

What arrived at your device wasn't a picture of a page. It was instructions — HTML describing the structure, a reference to a stylesheet describing how things should look, references to the images in this post.

Your browser read the instructions, went back out for the stylesheet and images (each one repeating a smaller version of this entire journey — the handshake was reused, thankfully), figured out where every letter and line should sit, and painted the result. That paint job, the part that finally made light hit your eyes, happened entirely on your device. My server has never seen this page the way you're seeing it. Truthfully, neither have I.

A page mid-construction in the dark: scaffolding of thin teal lines with blocks of text and image placeholders being lowered into place, half the page already lit and finished

Your visit, measured

Everything above happened to you, specifically, moments ago. If your browser supports it, here are the real numbers from your own load of this page — measured by your browser, displayed by a small script, and sent nowhere:

A third of a second, give or take. In that time: a distributed directory answered, an encryption key was born and will never be used again, a relay in a city near you vouched for you, a small computer assembled this page from a text file, and a few dozen envelopes crossed some meaningful fraction of the planet.

You'll do all of it again the next time you tap anything. Nobody will notice that time either. That's the strangest part — we built something this elaborate, made it complete its work in less time than a blink, and the reward for getting it right is that it feels like nothing happened at all.

The numbers panel above is read from your browser's own timing records (the Navigation Timing API), rendered on your screen, and never transmitted. If you want to know everything this site does and doesn't collect, the transparency page has the full honest accounting.