Computer Networking

What actually happens when one machine communicates with another? Ethernet, IP, routing, NAT, DNS, UDP, TCP, TLS, HTTP/1.1 → HTTP/3, WebSockets, proxies, load balancers, CDNs, firewalls — taught by following one web request from the browser through the kernel, the NIC, routers and the internet to a server process, and back.

Follow one operation through every layer

The defining experience: no “Client → Server” and stop. Every arrow can be expanded until you reach the hardware.

  1. Browser→
  2. DNS→
  3. TCP / QUIC→
  4. TLS→
  5. HTTP→
  6. Socket→
  7. Kernel→
  8. Network interface→
  9. Router→
  10. Internet→
  11. Server NIC→
  12. Kernel→
  13. Socket→
  14. Application
Learn → Visualize → Inspect → Simulate
Every mechanism is derived from the constraint it solves, then shown as a stepped simulation you can run, pause, step and reset.
Break → Debug → Practice → Interview
Labs let you exhaust memory, deadlock threads, drop packets and expire certificates; challenges make you find the root cause across layers.
Accuracy over slogans
Sections are labelled CONCEPTUAL · LINUX · UNIX-STYLE · WINDOWS · IPV4 · IPV6 · SIMULATED · RUNTIME-SPECIFIC so you always know whether you are reading a model or an implementation.

Start here

Learn
80 lessons across 17 modules — each derived from a problem, with a “why does this exist?” section and accuracy labels.
Journeys
3 “what happens when I…?” walks with zoomable depth. Every node is clickable; no step is magic.
Packet Lab
Follow one packet hop by hop, then drop packets, add latency, expire a certificate, block a port — and predict what breaks.
Connection Debugger
“Why can’t I connect?” and “polling, SSE, WebSockets or HTTP/3?” — decision trees with reasons.
Practice
15 investigation-style debugging challenges: symptoms, evidence, red herrings, root cause across layers.
Interview
31 questions with beginner / strong / expert answers, green and red flags, follow-ups.

Journeys

“What actually happens when I…?” — zoom from four boxes to the full internals.

What happens when I open a website?
https://engineer-atlas.dev/dsa
4 levels · 14 nodes at full depth
What happens when my server reads a database row?
SELECT * FROM users WHERE id = 42
3 levels · 13 nodes at full depth
What happens when I send a packet?
send(sock, buf, len)
3 levels · 16 nodes at full depth

Modules

0/80 lessons mastered
How the Internet Works0/5
Press Enter on a URL and follow the request: layers, encapsulation, and an educational packet inspector.
What actually happens after you press Enter?
Ethernet, MAC & the Link Layer0/4
Local delivery: frames, MAC addresses, switches, broadcast domains, ARP for IPv4 and neighbor discovery for IPv6; switches versus routers.
I know the IP address. How does the frame find the right cable?
IP, IPv4, IPv6, Subnets, NAT & Ports0/6
Best-effort packet delivery, address structure, CIDR and subnetting, why IPv6 exists, NAT translation tables and what a port really is.
How does `192.168.1.42` know whether `10.0.0.7` is next door or across the world?
Routing0/3
Routing tables, longest-prefix match, next hops, and how the internet is stitched together from autonomous systems with BGP.
A router sees a destination IP and has three matching routes. Which wins, and why?
DNS0/4
From a name to an address: caches, recursive resolvers, root, TLD and authoritative servers, record types, TTLs — and a failure simulator.
Where does the IP for `engineer-atlas.dev` actually come from, and who is allowed to be wrong about it?
UDP0/1
Datagrams over IP with no connection, no ordering and no retransmission — and why DNS, real-time media and QUIC choose exactly that.
Why would anyone want a transport that can lose your data?
TCP0/8
A reliable ordered byte stream over an unreliable network: the handshake, sequence numbers, acknowledgments, loss recovery, flow control, congestion control, head-of-line blocking and the connection lifecycle.
How do you build a reliable stream out of packets that can be lost, duplicated and reordered?
TLS & Certificates0/3
TCP gives transport but not confidentiality or identity: the handshake, key agreement, certificates and the chain of trust.
How does my browser know it is talking to the real server, and not the coffee-shop Wi-Fi?
HTTP/1.1, HTTP/2 & HTTP/30/8
Requests, responses, headers and status codes; then the evolution from HTTP/1.1 through HTTP/2 multiplexing to HTTP/3 over QUIC; keep-alive and connection pooling.
Why did HTTP need three redesigns of its transport?
WebSockets, SSE & Polling0/2
Getting data from the server without asking: polling, server-sent events and WebSockets compared on directionality, infrastructure, reconnection and scale.
The server has news. How does it tell a browser that only ever asks?
Proxies, Load Balancers & CDNs0/3
Forward vs reverse proxies, L4 vs L7 balancing, health checks, and the networking view of a CDN: DNS, edge locations, caches and geographic distance.
When the client connects to "the server", what is it actually connected to?
Firewalls & VPNs0/2
Rules that allow or deny traffic by address, port and protocol; stateful inspection; encrypted tunnels.
A ping fails but the service works. What is a firewall actually blocking?
Container & Kubernetes Networking0/3
Network namespaces, virtual interfaces, bridges, and just enough Kubernetes to understand pod IPs, services, ingress and network policies.
Two containers on one host both bind port 80. How is that not a conflict?
Network Performance0/4
RTT, bandwidth, loss, retransmission, connection and TLS setup, queueing — and why a request is slow while the server CPU sits idle.
The server is idle and the request still takes 800 ms. Where did the time go?
Network Debugging & Capstone0/9
"Why can’t I connect?" as a layered procedure, the tools and which layer each answers, DNS/TCP/TLS/HTTP debugging — and the capstone: what happens when you visit `https://example.com`.
Connection timed out. Which of the nine layers failed?
Packet Lab0/2
Follow one packet hop by hop and inspect its state, then inject failures — loss, latency, DNS outage, expired certificate, blocked port — and predict the behaviour.
What changes in the packet at each hop, and what happens when a hop fails?
OS + Networking Together0/13
Follow `send()` through the socket API, the kernel, the transport stack and the NIC to a server that wakes up in `recv()`; build a tiny server from blocking to event-driven; buffers, backpressure, zero-copy and a combined failure simulator.
What actually happens between writing `send()` and another machine’s process waking up?

Connected to the other domains

These domains are one map, not isolated courses.

Networking ↔ OS
Every packet starts as a system call and ends as a process waking up in the scheduler.
The map
DSA queues → scheduler queues → socket buffers → message queues; virtual memory → OS pages → database pages → buffer pool.
The capstone
“A user in Warsaw opens your app hosted in another region and it takes 3 seconds. Explain every layer where the latency could originate.”