What's In a Click
My son slammed his fist on the desk at 2am.
I know this because I was awake too, doing that thing parents do where we pretend we're not monitoring our kids' emotional state through the thin walls of a sleeping house. He was in his room. Steam was open. Something wasn't working.
I heard him mutter "come on" in that specific tone that means a computer is refusing to cooperate. Then silence. Then the keyboard again.
I didn't intervene. He's eighteen. He built his own website last month. He can figure out why a game won't launch.
But the next morning, over coffee, he asked me something I wasn't expecting.
"What actually happens when I click something?"
The Arcade
Here's what he told me: He'd been trying to launch a game. Clicked Play. Nothing. Clicked again. Spinning icon. Clicked again, harder somehow, as if that would help. Then an error — connection timed out, server unavailable, something like that.
And instead of just alt-tabbing to Discord and waiting like he normally would, he sat there staring at the screen wondering why.
"Like, I clicked a button. On my computer. And it's trying to talk to a server somewhere? Where? How does it know where to go?"
I looked at my kid, who has probably "un-alived" approximately ten thousand people across Fortnite, Valorant, and Rainbow Six, double that if you add GTAV, without once wondering how any of it worked, and I saw something familiar.
He wanted in.
Not into the game. Into the machine.
Getting Digitized
The moment you click, you stop being a person at a keyboard. You become a request. A message. A packet of data with somewhere to be and no idea how to get there.
My son clicks Play in Steam. His computer assembles a request: I want to talk to the server that validates game licenses. Here's who I am. Here's what I need.
But here's the thing — this request doesn't happen locally, and his computer doesn't know where that server is. Not the address. Not the path. Nothing. It just knows a name. A domain. Letters that make sense to us as humans, but mean nothing to a machine.
He's standing in an arcade. The lights are off. Somewhere in the darkness is a door, but he can't see it.
The Recognizer
Before you can go anywhere on the Grid, something has to scan you. Identify you. Tell you where you belong.
That's DNS. Domain Name System. The first hop on every journey. It's like the Yellow Pages, for those of you who remember those; it converts names to numbers.
His computer calls out into the void: Who knows where this server lives?
A resolver responds. The resolver is local, nearby, provided by his ISP or maybe Cloudflare or Google. It's like the first program you meet — not hostile, not friendly, just... functional. It has one job.
I don't know, the resolver says. But I know who to ask.
So it asks the root servers. Thirteen clusters of machines scattered across the planet, the foundation of the entire naming system. They don't know the specific server either, but they know who handles .com domains. It's resolving an area code first.
The request bounces to the .com nameservers. Who handles this domain?
Another redirect. Another hop. Finally, a nameserver that actually knows: Here. This IP address. These four numbers. That's where your server lives.
216.58.214.206. Or something like it.
My son has coordinates now. The arcade lights flicker on. There's the door.
But the door is a thousand miles away.
Light Cycles
I used to host Quake servers in the late '90s. At work. Don't ask.
If you wanted to play, you needed my IP address. You'd type it in manually, click connect, and pray my Pentium could handle the load. We'd play over lunch. The guy with the best ping usually won. The guy hosting had zero ping and got called a cheater even though it was his computer doing all the work.
My son doesn't even know servers have locations. He clicks "Play" and matchmaking just... happens. Some algorithm somewhere picks a server with good ping, spins up a session, throws him in. Magic.
But it's not magic. It's routing. And routing is where the light cycles live.
His request — now armed with an IP address — needs to cross the internet. And although it provides it, the internet isn't a cloud. It's not some ethereal nothing. It's cables. Copper. Fiber optic lines running under oceans. Physical hardware in physical buildings making decisions about where to send each packet of information.
But first, someone has to organize the cargo. Every packet needs structure — data that any system can read, regardless of what language it speaks. At the application layer, a transporter named Jason often handles this. Curly braces, key-value pairs, everything labeled and nested just right, organizing your request and a server's response. He's been doing this job so long that most of the Grid forgot there was ever another way. JSON. The universal format. Without him, the whole system would just be screaming into the void. There are other transporters; XML, SOAP, one could argue even HTML, but Jason is pretty well-known and heavily-used.
His data hits a router. The router looks at the destination and makes a choice: This way. Not that way. This way. Milliseconds. Then the next router. Same decision. Then the next. You might picture a beam of light (and they often are) bouncing from place to place, competing with others, to arrive at their destinations as quickly as possible.
It's a race through a maze, except the maze is constantly shifting. Routes go down. Traffic builds up. Packets take different paths and arrive out of order. The routers don't care about the whole journey — each one only knows its neighbors, only makes one decision, only sends the packet one hop further.
Light cycles screaming through the Grid. No hesitation. No big picture. Just go left, go right, go straight, don't crash.
I think about the infrastructure I've spent my career building. Data centers I've stood up and torn down. Architectures I designed for banks, for retailers, for enterprises making the jump from products on store shelves to subscription services online (don't hate me). My son's packets might be racing through systems I helped build. He'd have no idea. Why would he?
He's Sam Flynn. Running across a Grid his father had a hand in designing.
He just doesn't know it yet.
The Gatekeeper
The request arrives. The server is real. The door is right there.
But the door doesn't open.
"This is the part I don't get," my son said. "Why does it need to, like, verify stuff? I already logged into Steam."
Welcome to TLS. Transport Layer Security, which you might know better as SSL. The security guard ensuring you are who you say you are. TSA at the airport. Bouncer at a club.
Before any real information flows, there's a negotiation. A ritual. Both parties need to prove who they are to each other; that they're not some imposter. My son's computer needs to prove it's allowed to be asking questions. The server needs to prove it has the correct answer. They need to agree on how to encrypt everything that follows so nobody listening in the middle can understand it.
It goes like this:
Client Hello. My son's computer reaches out. "Hey. I want to talk. Here's what encryption I understand." Encryption being a real-time secret language.
Server Hello. The server responds. "Cool. Let's use this encryption. And here's my certificate — proof I am who I say I am."
His computer checks the certificate. Is it signed by someone trustworthy? Is it expired? Is the name right? Like a license or a passport. This takes milliseconds but it's everything. This is why you can type your credit card into a website without (usually) getting robbed.
Key Exchange. They agree on a shared secret. Math happens. Beautiful, complicated math that means anyone eavesdropping sees only gibberish. Anyone want to read a piece on encryption - we can do that - comment below.
Finished. The handshake completes. The connection is secure.
The door opens.
CLU would be proud. If you know, you know.
The ISO
Here's the wild part: the request finally made it. DNS resolved. Routers routed. TLS handshook. His computer is talking to the server, encrypted and verified, asking for what it came for. The perfect image.
Is this license valid? Can this user play this game?
The server checks. Database queries fire. Business logic executes. Somewhere, ones and zeros determine whether my kid gets to shoot at his friends tonight.
Yes.
The response races back. Same journey in reverse, more or less. Routers handing off to routers. Fiber optic light screaming under the Atlantic. His local network picking up the packet and delivering it home.
And then — done. The game launches. He's in.
He never saw any of it.
End of Line
He sat back in his chair.
"So every time I play... all that happens?"
Every single time. Every match. Every click. DNS, routing, handshakes, servers, responses. Thousands of bits of data wrapped up in packets and put on the wire. Literally at the speed of light, to the point you can tell when a server is close or not.
He was quiet for a second.
"You used to do all that stuff. The servers and whatever."
"Still do."
"That's kind of cool."
It's not the ending from a movie. No portal. No dramatic escape. Just a kid sitting in his room, cocoa getting cold, realizing for the first time that the world he's been playing in for years was built by someone. By a lot of someones.
One of which lives in his house.
He didn't say anything else about it. Went back to his room, probably to click Play again. But I like to think something shifted. A recognition.
The Grid isn't magic. It's architecture. Infrastructure. Decades of decisions made by people who cared enough to get it right.
And now he knows it's there.
This is becoming a bit of a series, isn't it? Unexpected. And fun. Join us next time... Andrew gets his key... the game opens...