Networking, without the fluff

What actually happens between typing a URL and seeing a page — DNS lookup, TCP handshake, TLS negotiation, the HTTP exchange, response handling. The spine that connects every other topic here.

The single most-asked networking question there is, and a pure depth probe — anyone can name the steps, but interviewers keep asking "and then what?" to find where your mental model runs out.

The two transport protocols. TCP's three-way handshake, ordering, and reliability versus UDP's fire-and-forget speed. When you pay for guarantees and when you skip them.

The insight most people miss is that TCP's reliability can make things worse. A retransmitted video frame arrives too late to be useful — and stalls every frame behind it while it retries. Knowing when a guarantee becomes a liability is the whole point.

Methods, status codes, headers, and statelessness — plus the real differences between HTTP/1.1, HTTP/2 multiplexing, and HTTP/3 over QUIC.

Everyone knows 200 and 404. Knowing why HTTP/2 fixed head-of-line blocking at the application layer but not the transport layer is where senior signal starts.

How names become addresses. Recursive vs authoritative resolvers, record types (A, CNAME, MX), caching, and TTLs.

"It's always DNS" is a joke because it's true. The engineers who debug outages fastest are the ones who suspect a stale TTL before they suspect the app.

How the encrypted channel gets built — the handshake, certificates and chains of trust, symmetric vs asymmetric keys, and what's actually protected.

Most candidates say "it's encrypted" and stop. Explaining why the handshake uses asymmetric keys just to agree on a symmetric one is the line between using TLS and understanding it.

Distributing traffic across servers. L4 vs L7 balancing, reverse proxies, CDNs, and the routing algorithms — round-robin, least-connections, consistent hashing.

Every system-design round eventually asks "how does the request reach the right server?" — L4-vs-L7 is the answer that shows you've operated a system, not just drawn one.

The programming-facing side — opening sockets, connection pooling, keep-alive, timeouts, and the finite pool of ports and file descriptors.

This is where networking stops being trivia and becomes production incidents. Port exhaustion and leaked connections are the outages that teach it to you the hard way.

Bandwidth versus latency, round-trip time, and why they're different levers. Congestion control, the bandwidth-delay product, and where the milliseconds actually go.

The classic mistake is throwing servers at a latency problem. More capacity serves more requests — it does nothing for a single request that's slow because it's waiting on round-trips. Telling a latency problem from a throughput problem is the actual skill.