Visual course · Systems fundamentals

How the internet works.

You press Enter and a page appears — but between those two moments a dozen systems race across the planet to make it happen. This course follows one web request the whole way: how a name becomes an address, how data is chopped into packets and made reliable, how the request is spoken and secured, and how a server thousands of miles away still feels instant. Seven short episodes, each embedded with the deeper reference.

7 episodes ~90 min One request, end to end Free · no sign-up
Your progress0 / 7 complete

What you'll understand

By the end you'll be able to trace a request from your keyboard to a server and back, and name every layer it crosses: DNS resolution, IP routing and packets, TCP's reliability, the HTTP request/response, the TLS handshake that secures it, and the CDN edge that makes it fast. It's the mental model every backend, frontend and systems interview quietly assumes you already have.

DNSIPPacketsTCPHTTPHTTPSTLSCDNEdge cachingRouting
The curriculum

Seven episodes, in order

01
Episode 1 · The Journey

What Really Happens When You Hit Enter

Type a URL, press Enter, and a dozen systems spring into action to get bytes from a server thousands of miles away onto your screen in a heartbeat. This is the whole journey in one map — the rest of the course zooms into each stop.

What you'll learn
  • The full request lifecycle at a glance
  • DNS → TCP → TLS → HTTP, in order
  • Where each layer fits
02
Episode 2 · DNS

How "google.com" Becomes a Number

Computers route by numbers, not names. DNS is the internet's phone book: it turns google.com into an IP address by walking a chain of nameservers — root, TLD, authoritative — with caching at every step so the lookup stays fast.

What you'll learn
  • The resolver → root → TLD → authoritative chain
  • Records (A, CNAME) + TTL caching
  • Why DNS is fast despite the hops
03
Episode 3 · IP & Packets

1 Photo, 1,000 Packets

Your data isn't sent as one blob — it's chopped into thousands of small packets, each stamped with a destination and routed independently across the network, then reassembled at the far end. It's why the internet is resilient: no single path has to survive.

What you'll learn
  • Packets, headers and addressing
  • Independent routing + reassembly
  • Why packet-switching beats circuits
04
Episode 4 · TCP

Packets Get Lost — Your Webpage Doesn't

Packets get lost, duplicated and arrive out of order — yet your page renders perfectly. TCP is the layer that turns an unreliable packet network into an ordered, guaranteed byte stream, using sequence numbers, acknowledgements and retransmits.

What you'll learn
  • The three-way handshake
  • Sequence numbers + ACKs + retransmit
  • How reliability is built on unreliability
05
Episode 5 · HTTP

The Whole Web Is Just Text

Under the web is just text: a request naming a method and a path, and a response with a status code and a body. Once you see that a web page starts as a plain-text conversation, HTTP stops being mysterious and status codes start making sense.

What you'll learn
  • Methods, paths, headers, bodies
  • Status codes (2xx/3xx/4xx/5xx)
  • Requests + responses as plain text
06
Episode 6 · HTTPS & TLS

Agreeing on a Secret in Public

How do two strangers agree on a secret key while everyone is listening? The TLS handshake uses public-key cryptography to establish an encrypted channel and verify who you're talking to — so ordinary HTTP rides safely inside HTTPS.

What you'll learn
  • Public-key vs symmetric crypto
  • The TLS handshake + certificates
  • What the padlock actually proves
07
Episode 7 · CDNs · Finale

8,000 Miles Away, Yet Instant

The finale ties the journey off: a server 8,000 miles away still feels instant because a CDN keeps copies of the content close to you. Edge caching, anycast routing and cache invalidation are how the web scales to a planet of users without melting the origin.

What you'll learn
  • Edge caching + points of presence
  • Anycast routing to the nearest edge
  • Cache invalidation + TTLs

Traced the request? Now design the systems.

Every layer you just followed becomes a design problem at scale. The interactive system-design walkthroughs build the DNS, CDN, load balancer and API gateway you met here — step by step.