How Packets Actually Travel Across the Internet

The Great Insight: Why Circuit Switching Failed

In the early 1960s, the world’s only global telecommunication network was the telephone system. It operated on Circuit Switching:

• When you dialed a telephone number from New York to London, electromechanical telephone exchanges physically clicked copper switches into place, reserving a dedicated, continuous physical wire between your handset and the other person's receiver.
• While you talked, that electrical circuit was yours. Even if both speakers stayed completely silent for ten minutes, that copper line remained reserved, unusable by anyone else on Earth.

Circuit switching had a fatal architectural limit: it was brittle and shockingly inefficient. A single bomb or broken trunk wire severed the connection. Furthermore, computers communicate in short, sudden bursts of data rather than continuous audio streams. Reserving a dedicated transatlantic line so a computer could transmit one small data file every twenty minutes was economically impossible.

Between 1960 and 1965, two researchers working independently—Paul Baran at the RAND Corporation in the United States and Donald Davies at the National Physical Laboratory in Britain—invented a radical alternative: Packet Switching.

Baran asked: What if we never reserve a dedicated line?

Instead:

1. Chop every piece of digital information into tiny, standardized envelopes called Packets.
2. Put the recipient’s address on every single envelope.
3. Throw all packets into a decentralized web of forwarding nodes (Routers).
4. Let each router inspect each envelope independently and fling it down whatever wire is least busy at that split second.

The packets might travel across completely different physical paths: one packet through Chicago, another through Atlanta, another through undersea cables. At the destination, the receiving computer gathers all the envelopes, sorts them back into order, and glues the message back together.

Today, every email you send, every YouTube video you stream, every credit card swipe, and every webpage download travels across the planet as a swarm of independent packets.

Here is the physical journey of a single packet traveling from your screen to a server 10,000 kilometers away.

Step 1: Slicing the File into Packets (The MTU)

Imagine you want to upload a 5-megabyte photograph ($5,242,880\text{ bytes}$) to a website.

Your computer does not send that 5-megabyte blob as a single continuous transmission. If it did, and a single millisecond of static corrupted a single bit near the end, your computer would have to retransmit all 5 megabytes from scratch. Furthermore, no other device in your house could send or receive a single byte while your massive file hogged the Wi-Fi router.

Instead, the operating system's networking stack slices your 5-megabyte file into roughly 3,600 small chunks.

       CHOPPING A 5 MB IMAGE INTO 1,500-BYTE PACKETS

       [ 5,242,880 Byte Photo ]
              │
              ├──► Packet #1    [ Payload: 1,460 Bytes ]
              ├──► Packet #2    [ Payload: 1,460 Bytes ]
              ├──► Packet #3    [ Payload: 1,460 Bytes ]
              │    ...
              └──► Packet #3600 [ Payload: 880 Bytes ]

Why 1,500 Bytes? (The MTU)

Almost every network link on the global internet adheres to a standard called the Maximum Transmission Unit (MTU) of 1,500 bytes.

Why 1,500? In 1973, when Robert Metcalfe and his colleagues at Xerox PARC invented Ethernet, they needed a buffer size that balanced efficiency against memory cost. A 1,500-byte buffer fit into inexpensive 2-kilobyte SRAM chips while ensuring that small errors did not force massive retransmissions.

That 50-year-old engineering compromise became the de facto physical gauge of the worldwide internet.

Step 2: The Russian Nesting Dolls of Encapsulation

Before a packet can leave your machine, the operating system must package it. It does this by wrapping the data payload in layers of protocol headers—like nesting a letter inside multiple envelopes:

                  THE DATA PACKET ENCAPSULATION STACK

    ┌─────────────────────────────────────────────────────────────┐
    │ 1. APPLICATION DATA (HTTP / JSON / Video chunk: 1,460 B)    │
    └─────────────────────────────────────────────────────────────┘
                                  │
                                  ▼ (Wrap in TCP Transport Header)
    ┌──────────────┬──────────────────────────────────────────────┐
    │  TCP HEADER  │              APPLICATION PAYLOAD             │
    │  (20 Bytes)  │                 (1,460 Bytes)                │
    └──────────────┴──────────────────────────────────────────────┘
                           │
                           ▼ (Wrap in IP Network Header)
    ┌──────────────┬──────────────┬───────────────────────────────┐
    │  IP HEADER   │  TCP HEADER  │      APPLICATION PAYLOAD      │
    │  (20 Bytes)  │  (20 Bytes)  │         (1,460 Bytes)         │
    └──────────────┴──────────────┴───────────────────────────────┘
                    │
                    ▼ (Wrap in Ethernet Data Link Frame)
    ┌──────────────┬──────────────┬──────────────┬────────────────┬──────────────┐
    │ ETHERNET HDR │  IP HEADER   │  TCP HEADER  │  APP PAYLOAD   │ ETHERNET FCS │
    │  (14 Bytes)  │  (20 Bytes)  │  (20 Bytes)  │ (1,460 Bytes)  │  (4 Bytes)   │
    └──────────────┴──────────────┴──────────────┴────────────────┴──────────────┘
    │◄───────────────────────── 1,518 Bytes Total ──────────────────────────────►│

Look at the microscopic anatomy of those headers:

1. The TCP Header (Layer 4 - Transport)

The Transmission Control Protocol (TCP) header is 20 bytes long. It contains:

• Source Port & Destination Port: e.g., Port 443 (HTTPS) or Port 53 (DNS).
• Sequence Number: A 32-bit counter (e.g., 3,402,192,800). This tells the receiving computer exactly where this chunk belongs in the reassembled file.
• Acknowledgment Number: Confirms which bytes have been safely received.
• Flags: Single-bit control lights: SYN (start connection), ACK (acknowledge receipt), FIN (clean shutdown), RST (abort).

2. The IP Header (Layer 3 - Network)

The Internet Protocol (IPv4) header is another 20 bytes:

• Source IP Address: The 32-bit address of your machine (e.g., 192.168.1.50).
• Destination IP Address: The 32-bit address of the destination server (e.g., 142.250.190.46).
• Protocol: Identifies what is inside (Protocol 6 = TCP, Protocol 17 = UDP).
• Time-To-Live (TTL): A hop counter (typically set to 64 or 128).

Step 3: Leaving the House (Ethernet and Wi-Fi)

The fully wrapped packet is now handed to your network interface card (NIC).

Your computer wants to send this packet to Google's server at 142.250.190.46. But your computer cannot talk directly to Google. It can only talk to the local Wi-Fi router sitting on your desk.

1. Your computer wraps the IP packet inside a Layer 2 Ethernet frame (or IEEE 802.11 Wi-Fi frame).
2. It sets the destination MAC address to the hardware address of your home Wi-Fi router (the Default Gateway).
3. The Wi-Fi chip modulates the digital bits into high-frequency radio waves (as detailed in How Wi-Fi Actually Works).
4. The router receives the radio wave, strips off the Wi-Fi frame, and inspects the raw IP header inside.

The router sees: Destination: 142.250.190.46.

Now the global relay begins.

Step 4: Inside a Core Router (The Nanosecond Decision)

A high-end internet router (such as a Cisco 8000 or Juniper PTX series) does not look like your home box. It is a refrigerator-sized chassis installed in a telecommunication data center, routing over 100 Terabits of data per second.

When your packet arrives at an optical input port of a core router, the router has less than 10 nanoseconds to decide which of its hundreds of output fiber cables should receive the packet.

               ANATOMY OF A CORE ROUTER FORWARDING ENGINE

    Input Optical Fiber
           │
           ▼
    [ Physical Layer: Photodiode ] ──► Converts laser pulses into electrical bits
           │
           ▼
    [ ASIC Packet Buffer ] ──────────► Parses IP header; extracts Destination IP
           │
           ▼
    [ TCAM Routing Search ] ─────────► Longest Prefix Match (LPM) in 1 clock cycle!
           │                           Matches 142.250.0.0/16 ──► Output Port #4
           ▼
    [ TTL Decrement & Checksum ] ────► Decrements TTL (64 ──► 63); recalculates CRC
           │
           ▼
    [ Crossbar Switch Fabric ] ──────► Flings packet across backplane to Port #4
           │
           ▼
    [ Output Laser Transmitter ] ────► Pulses infrared laser into transoceanic fiber!

The router does not search through billions of individual IP addresses. It uses CIDR (Classless Inter-Domain Routing) prefixes stored in a Forwarding Information Base (FIB):

    Prefix Match Rule               Output Port
    ──────────────────────────────────────────────
    0.0.0.0/0 (Default)             Port 1 (Upstream Transit)
    142.0.0.0/8                     Port 2 (North America)
    142.250.0.0/16                  Port 4 (Google Autonomous System)
    142.250.190.0/24                Port 7 (Direct Peering Link)

The router uses an algorithm called Longest Prefix Match (LPM). Because rule #4 matches the most specific number of bits (/24 is more specific than /16), the router selects Port 7.

To do this in a single clock cycle, routers use specialized hardware called TCAM (Ternary Content-Addressable Memory): memory chips that search an entire million-route table in parallel in a fraction of a nanosecond.

The Safety Valve: The TTL Decrement

Before the router forwards the packet, it performs a critical physical modification:

$$\text{TTL}{\text{new}} = \text{TTL}{\text{old}} - 1$$

It decrements the Time-To-Live field by exactly 1.

Why? If two routers have a configuration bug where Router A forwards to Router B and Router B forwards right back to Router A, a packet would circulate in an infinite loop forever. If thousands of packets were trapped in this loop, the fiber optic link would choke with traffic and melt down.

Because of TTL, when a packet circulates through 64 hops, its TTL hits zero.

The router that decrements it to zero instantly drops the packet into the trash and sends back an ICMP error message: "Time Exceeded in Transit". (This exact mechanism is how the diagnostic utility traceroute maps every router between you and a destination!)

Step 5: Crossing the Ocean Floor (Submarine Fiber)

Once your packet leaves your regional Internet Service Provider (ISP), it enters the global backbone: Tier-1 Autonomous Systems (like Lumen, Telia, NTT, or Tata Communications) connected via the Border Gateway Protocol (BGP).

To cross from North America to Europe or from Mumbai to Singapore, your packet must cross an ocean.

It does not bounce off satellites in space (which would introduce an unbearable 500-millisecond latency penalty). It dives to the bottom of the ocean through an Undersea Submarine Fiber Optic Cable.

                 ANATOMY OF AN UNDERSEA FIBER CABLE

                     ┌───────────────────────────────┐
                     │ Polyethylene Outer Jacket     │
                     ├───────────────────────────────┤
                     │ Mylar Tape Barrier            │
                     ├───────────────────────────────┤
                     │ Stranded Steel Strength Wires │
                     ├───────────────────────────────┤
                     │ Aluminum Water Barrier        │
                     ├───────────────────────────────┤
                     │ Polycarbonate Insulating Pipe │
                     ├───────────────────────────────┤
                     │ Copper Power Conductor Tube   │
                     ├───────────────────────────────┤
                     │ Petroleum Jelly Thixotropic   │
                     ├───────────────────────────────┤
                     │ Pure Glass Optical Fibers     │  ◄── THINNER THAN A HAIR!
                     └───────────────────────────────┘

A submarine cable is resting on the ocean floor, under miles of cold saltwater and immense pressure. Yet the cable itself is only the thickness of a garden hose.

At its dead center sit pairs of hair-thin fibers made of ultra-pure silica glass.

Your electrical packet is converted into infrared laser pulses oscillating at wavelengths around $1,550\text{ nanometers}$. Using Dense Wavelength Division Multiplexing (DWDM), up to 100 different colored laser beams flash simultaneously through the single glass strand.

Photons bounce down the silica core through total internal reflection, traveling at roughly 200,000 kilometers per second (about two-thirds the speed of light in a vacuum, slowed down by the refractive index of glass).

The Undersea Amplifiers (EDFA)

As photons travel through 100 kilometers of glass, they scatter and attenuate.

Every 60 to 80 kilometers along the ocean floor, the cable passes through a submarine Optical Repeater: a titanium cylinder containing an Erbium-Doped Fiber Amplifier (EDFA). A high-power pump laser energizes erbium ions inside the glass, amplifying the weakened light pulses purely optically—without ever converting the photons back into electricity.

The packet crosses 6,000 kilometers of the Atlantic Ocean in roughly 30 milliseconds.

The End-to-End Hop-by-Hop Choreography

The sequence diagram below traces the end-to-end journey of an IP packet from your home laptop, across local Wi-Fi, regional ISPs, transoceanic fiber, down to the destination server:

Step 6: Arrival and TCP Reassembly

When the 3,600 packets arrive at the destination server, they do not arrive in orderly single-file fashion.

Because different packets took slightly different routes through core routers, they arrive scrambled and out of order:

• Packet #1 arrives first.
• Packet #3 arrives second.
• Packet #2 arrives third.
• Packet #14 is dropped by a congested router buffer in Frankfurt and never arrives at all!

This is where TCP performs its magic.

The operating system kernel on the receiving server places incoming packets into a TCP Receive Buffer:

1. It inspects the Sequence Numbers in the TCP headers and sorts the packets back into strict mathematical order.
2. When it notices that Packet #14 is missing, it sends an acknowledgment (SACK: Selective ACK) back to your computer: "I have received bytes up to #13 and bytes from #15 to #20, but I am missing #14."
3. Your computer retransmits only Packet #14.
4. Once all chunks are present, the kernel strips off the TCP and IP headers, concatenates the raw payloads into a seamless 5-megabyte stream, and wakes up the web application:

read(socket_fd, image_buffer, 5242880);

The application receives the complete photograph. It has no idea that its file was chopped into 3,600 pieces, pulsed as radio waves, evaluated by TCAM memory in microseconds, and beamed through glass strands beneath the sea.

The Resilient Web

The miracle of the internet is not that it is fast. The miracle is that it works without any central commander.

There is no master computer controlling internet traffic. There is no supreme authority deciding which route your packet must take.

Instead, the global internet is a massive, self-healing federation of thousands of independent networks bound together by simple, universal physical protocols:

• Slicing data to respect the 1,500-byte MTU.
• Formatting addresses with IP headers.
• Decrementing TTL to prevent catastrophic loops.
• Bouncing laser light across ocean floors.
• Using TCP sequence numbers to reassemble order from chaos.

Every time you tap a screen, billions of microscopic packets set off across the globe, independently navigating the planetary labyrinth of silicon and glass, finding their way home in a fraction of a heartbeat.