How the Web Works
URLs, DNS, HTTP, status codes, cookies, and caching — what actually happens between typing an address and seeing a page, traced with your browser's DevTools and curl.
You use the web every day, and as a developer you'll build for it every day. But most of what happens after you press Enter in the address bar is invisible: a name turned into a number, a connection opened and encrypted, a request sent, a response sent back, and dozens more requests fired off before the page appears. When something breaks — a 404, a CORS error, a login that won't stick, a change that won't show up — that invisible part is where the problem is.
This series makes it visible. It starts with what the web actually is, then follows one address through every step: the parts of a URL, how DNS finds the server, how the connection is made and secured, what an HTTP request and response really look like, and how the browser turns the response into pixels. Then it covers the things that make the web feel fast and personal — cookies, sessions, caching, and CDNs — and the difference between static sites, web apps, and APIs. The final chapter traces one URL from keypress to pixels using everything from the chapters before it.
You won't write an app, but you will look at real traffic yourself,
with two tools you already have: your browser's DevTools and
curl in a terminal. Your main example is the GitHub Pages site you
published at the end of Git & GitHub for
Beginners; if you skipped that, any
public website works.
You need a computer running Windows, macOS, or Linux, a modern browser (Chrome, Edge, or Firefox), the terminal setup from Command Line Basics, and an internet connection. Nothing costs money.
- 01What Is the Web?The internet vs. the web, clients and servers, what a browser really is, a map of what happens when you open a page, and your first look at the DevTools Network tab.
- 02URLs, Piece by PieceThe scheme, host, port, path, query string, and fragment of a URL, what the browser does with each one, percent-encoding, and absolute vs. relative links.
- 03IP Addresses and DNSWhat an IP address is, IPv4 vs. IPv6, private addresses and localhost, how DNS turns a name into a number step by step, the record types you'll set up yourself, and why DNS changes take time.
- 04Connections: TCP, Ports, and TLSHow packets become a reliable connection with TCP, how ports pick the right program, what HTTPS and the padlock really protect, how certificates work, and why every new connection costs time.
- 05HTTP RequestsWhat an HTTP request really looks like: the request line, methods like GET and POST, the headers browsers send, the body, and how to read it all with curl -v and DevTools.
- 06HTTP Responses and Status CodesThe shape of an HTTP response, the five families of status codes and the ones you'll actually meet, redirects, the difference between 401 and 403, Content-Type, and how to read a real response from GitHub Pages.
- 07Inside the Browser: From HTML to PixelsHow the browser parses HTML into the DOM, why one page turns into dozens of requests, what blocks rendering, how layout and paint put pixels on the screen, and how to read the Network waterfall.
- 08Cookies, Sessions, and StateWhy HTTP forgets everything between requests, how cookies make websites remember you, how logins and sessions work, the cookie settings that keep them safe, localStorage, and third-party tracking.
- 09Caching, CDNs, and SpeedHow browsers avoid downloading the same thing twice with Cache-Control, ETags, and 304s, why your GitHub Pages change takes minutes to show up, hard refresh, compression, and how CDNs bring servers closer to you.
- 10Static Sites, Web Apps, and APIsStatic sites vs. server-rendered pages vs. single-page apps, what an API is and why it speaks JSON, a quick look at CORS, and where the Frontend and Backend tracks pick up from here.
- 11Putting It All TogetherOne URL traced from keypress to pixels, using every chapter of the series, then a recap, a debugging checklist, a curl and DevTools cheat sheet, what the series left out, and where to go next.