What happens in the 50 milliseconds between you pressing Enter and a webpage appearing? The answer is one of the most elegant engineering stories ever told.
The Packet: The Atom of Modern Communication
Everything you send over the internet — a message, a video frame, a command to a smart bulb — gets shredded into tiny pieces called packets. A single email might become 30 packets. A Netflix stream might explode into thousands per second.
Each packet is essentially a tiny envelope containing:
- A header: where it came from, where it’s going, what position it holds in the sequence
- A payload: the actual data chunk
- A trailer: error-checking bits to catch corruption
Why chop things up? Because a single large “envelope” would be inefficient — it would hog the wire for everyone else, and if it got corrupted, you’d resend the whole thing. With packets, only the damaged ones get resent. The rest arrive and reassemble themselves in silence.
This idea — packet switching — was radical when Paul Baran proposed it in 1964. The U.S. military thought he was insane. The telephone companies laughed. Today it underpins every digital communication on Earth.
The Stack: Seven Layers of Organized Chaos
The OSI model is the conceptual map of how networks work. Think of it as a seven-story building where each floor has exactly one job and knows nothing about the floors above or below it.
┌─────────────────────────────┐
│ 7. Application (HTTP, DNS)│ ← What you actually use
│ 6. Presentation (TLS, JPEG)│ ← Encoding & encryption
│ 5. Session (Auth) │ ← Maintaining connections
│ 4. Transport (TCP, UDP) │ ← Reliability & ports
│ 3. Network (IP) │ ← Addressing & routing
│ 2. Data Link (Ethernet) │ ← Frames & MAC addresses
│ 1. Physical (Cables) │ ← Actual bits on wire
└─────────────────────────────┘When you load a website, data falls down this stack on your machine, flies across the internet as raw signals, then climbs back up the stack on the server. Every layer adds its own header on the way down, and strips it on the way up — a process called encapsulation. It’s elegant to the point of being almost philosophical: each layer is sovereign, yet the whole system cooperates perfectly.
TCP vs UDP: The Reliability Trade-off
Two protocols dominate the transport layer, and they represent opposing philosophies.
TCP (Transmission Control Protocol) is obsessive about correctness:
- It performs a three-way handshake before sending anything (
SYN → SYN-ACK → ACK) - Every packet is acknowledged; lost ones are retransmitted
- Data arrives in order, guaranteed
UDP (User Datagram Protocol) just fires and forgets:
- No handshake, no acknowledgment, no ordering
- If packets drop, they’re gone
Which is better? Neither. They solve different problems:
| Use Case | Protocol | Why |
|---|---|---|
| Loading a webpage | TCP | You need every byte, in order |
| Video call | UDP | A dropped frame beats a 3-second freeze |
| Online gaming | UDP | Latency kills you; a lost update doesn’t |
| File download | TCP | Corruption is unacceptable |
| DNS lookup | UDP | One tiny question, one tiny answer — fast |
The genius of the internet is that it doesn’t force a single choice. Your browser and your voice call coexist, each using exactly the right tool.
Routing: How Packets Find Their Way
The internet has no central switchboard. There is no master router that knows where everything goes. Instead, routing is distributed and emergent — each router makes its own local decision about where to forward a packet next.
Routers share topology information using protocols like BGP (Border Gateway Protocol), which is effectively the internet’s nervous system. Every major network (an ISP, a cloud provider, a university) is an Autonomous System (AS), and BGP lets them announce: “I can reach these IP ranges.”
This creates a fascinating fragility. In 2010, a misconfiguration by a small Pakistani ISP accidentally announced that it owned YouTube’s IP space. BGP, faithfully following the rules, propagated this lie globally. YouTube vanished from the internet for two hours. The entire routing fabric of the planet believed in a single typo.
The fix for this — RPKI (Resource Public Key Infrastructure) — is still being rolled out. In 2024, less than half of all internet routes are cryptographically verified. The network most critical to civilization runs largely on trust.
DNS: The Phone Book That Never Sleeps
You type github.com. Your computer has no idea what IP address that is. So it asks.
The Domain Name System is a globally distributed database, queried billions of times per second. When you request a domain name, a resolver works through a hierarchy:
- Root nameservers (13 logical clusters, hundreds of physical machines) know which servers handle
.com - TLD nameservers know which server handles
github.com - Authoritative nameservers for
github.comreturn the actual IP
The whole lookup takes under 10 milliseconds. Then the answer is cached — locally on your machine, at your ISP, in your router — so subsequent lookups are instant.
DNS is so fundamental that it’s become a battleground. Governments censor by poisoning DNS responses. Advertisers hijack failed lookups for revenue. Security researchers track malware through DNS queries. And DNS-over-HTTPS is quietly encrypting these lookups, making them invisible to everyone except the resolver you choose.
The humble phone book became political.
The Edge: Where the Cloud Meets the Ground
Modern networks aren’t just about getting data from A to B — they’re about where you store data in the first place.
Content Delivery Networks (CDNs) like Cloudflare and Akamai operate hundreds of Points of Presence (PoPs) around the world. When you load a popular website, you’re probably not connecting to a server in a data center owned by that company. You’re connecting to a server in a building 20 kilometers from your house.
This matters because:
- Light travels through fiber at roughly 200,000 km/s
- A round-trip from Kyiv to California takes ~150ms at the speed of light
- A round-trip from Kyiv to a Frankfurt PoP takes ~8ms
That 142ms difference is the gap between a website that feels alive and one that feels sluggish. The entire CDN industry — worth tens of billions of dollars — exists to fight the speed of light.
The Future Beneath the Surface
Several quiet revolutions are reshaping networks right now:
IPv6 is finally gaining serious traction. IPv4 gave us ~4.3 billion addresses — we ran out in 2011. IPv6 provides 340 undecillion addresses (3.4 × 10³⁸). Every grain of sand on Earth could have a billion addresses. We are, slowly, migrating.
QUIC — the protocol underlying HTTP/3 — replaces TCP’s aging foundations with something built for modern networks: faster handshakes, better handling of packet loss, and multiplexing that doesn’t suffer from head-of-line blocking. Most of your Google traffic already uses it.
Software-Defined Networking (SDN) separates the “control plane” (deciding where traffic goes) from the “data plane” (actually forwarding it), letting networks be reconfigured in software in milliseconds. The dividing line between hardware and software is dissolving.
And somewhere underwater, 400,000 kilometers of submarine cables carry 99% of international internet traffic — invisible, vulnerable, and absolutely critical. A single cable cut can reshape traffic patterns across entire continents.
Why This Matters Beyond the Technical
Networks are infrastructure in the truest sense: the invisible substrate on which everything else depends. They carry not just data but economic activity, political organizing, personal relationships, medical records, and financial systems.
Understanding how they work — even at a high level — changes how you think about reliability, trust, and architecture. Every abstraction leaks eventually. When your video call drops, you’re not experiencing a software bug. You’re experiencing the physical reality of packets competing for bandwidth on a shared medium, TCP timers firing, and routers making split-second decisions.
The network doesn’t care about your deadline. It just follows the rules.
And somehow, most of the time, that’s enough.
Want to go deeper? Start with Beej’s Guide to Networking Concepts, then read the original TCP/IP specification — RFC 793 from 1981. It still works, unchanged, on every device you own.