Networking Deep Dive
by Sergey Okinchuk
Ch. 1

Networking Deep Dive

Welcome

A vendor-neutral, engineer's guide to how a packet actually moves from one process to another — across the link, IP, transport, and application layers — and where each layer fails in production.

≈16 hours to complete Knowledge check on every topic

About This Course

Networking is the subject every engineer half-knows. You can reach a database, terminate TLS, and read a status code without ever being able to say what happens between the application calling connect() and the bytes arriving on the other side. That gap is fine until the day a transfer hangs at exactly 1500 bytes, a peering link drops half your routes, or a certificate expires at 3am — and then the half-knowledge runs out.

This course closes the gap from the bottom up. It follows one packet from the wire through the link, IP, transport, and application layers, then turns to the cross-cutting concerns engineers actually operate: DNS, TLS, load balancing, security, observability, and the modern overlay and cloud networks built on top of all of it. The goal is a working model you can reason from, not a pile of commands to memorize.

Every topic follows the same shape: what it is, how it works, when it bites, the specific mistakes that cause real outages, and the practices that prevent them. Where two mechanisms compete — TCP versus UDP, L4 versus L7, GeoDNS versus anycast — the course compares them and says when each one fits, rather than leaving that judgment to you.

Who This Is For

Working engineers — backend, platform, SRE, security — who build on networks and want to stop treating them as a black box. The beginner can read it in order to build the model from the link layer up; the experienced engineer can jump to a topic to settle a design question or diagnose a class of failure. It assumes you know what an IP address, a port, and a client-server request are, and takes you from there to BGP, QUIC, mTLS, and bufferbloat.

What You Should Already Know

  • That a computer has an IP address and reaches other machines over a network
  • Roughly what a client and a server are — one asks, the other answers
  • Comfort on a command line, since the diagnostic tools are shown as you would run them
  • No prior networking theory, certification, or subnetting math required

New to this? Start with Computing Foundations from Zero - the first chapter of every course is free, and the rest is one membership.

How the Course Is Built

The fourteen chapters move outward from the wire. The first five build the stack in the order packets traverse it — foundations, the link layer, IP addressing, routing, and the transport layer — because everything later depends on them. The middle chapters cover the services engineers run on top: DNS, HTTP, TLS, security, load balancing, and observability. The final chapters take on performance troubleshooting, the overlay and cloud networks that hide the fundamentals behind an API, and the design principles that keep a network up.

The course is deliberately vendor-neutral. It teaches the protocols and mechanisms — Ethernet, IP, TCP, DNS, TLS, BGP — that are the same whether you run them on bare metal, in a datacenter, or behind a cloud provider's console. Where a protocol maps to a managed service, the comparable-tools row names the equivalent on the major clouds, so the knowledge transfers in both directions.

Follow the packet
Almost every concept becomes obvious once you trace a single packet through it. The course leads with that path — wire to process — and hangs the details off it rather than starting from a glossary.
The network promises nothing
IP is best-effort: it can drop, reorder, and duplicate. Every reliability guarantee you rely on is something an endpoint builds back on top. Knowing where that line sits explains most of networking.
The trade-offs are the point
TCP or UDP, terminate or pass through, low TTL or high — the right answer depends on the workload. The course says which, and what each choice costs, instead of declaring a universal best.
Failures have a layer
"The network is down" is never the diagnosis. It is DNS, or a route, or MTU, or a firewall — one specific layer. The course teaches the method that finds which, so you localize instead of guess.

Chapter Map

Chapter 1
Foundations
The ideas everything else stands on — packet switching, the layered model, encapsulation, the three address spaces, and the difference between bandwidth, latency, and throughput.
Chapter 2
The Link Layer
Ethernet frames and MAC addresses, how switches learn and forward, ARP, VLANs, the MTU that quietly breaks large transfers, and the loops spanning tree exists to prevent.
Chapter 3
IP and Addressing
The IPv4 datagram, subnetting and CIDR as a hands-on skill, private addressing, the NAT that saved IPv4 and broke end-to-end, IPv6, and DHCP.
Chapter 4
Routing
How a routing table and longest-prefix match decide every hop, default gateways, static versus dynamic routing, OSPF inside an organization, BGP across the internet, and anycast.
Chapter 5
The Transport Layer
Ports and sockets, UDP's minimalism, TCP's handshake and reliability, flow control versus congestion control, and the lifecycle issues that surface as port exhaustion.
Chapter 6
DNS
The distributed namespace, the resolution path, record types, the TTL that governs every cutover, DNSSEC and encrypted DNS, and operating authoritative DNS as a traffic tool.
Chapter 7
Application Layer and HTTP
The client-server model, HTTP from 1.1 through 2 to 3 over QUIC, cookies and sessions, WebSockets and server-sent events, and gRPC for service-to-service calls.
Chapter 8
TLS, Certificates, and PKI
What TLS actually guarantees, the handshake from 1.2 to 1.3, certificates and the chain of trust, revocation, and mutual TLS as the basis of zero-trust service identity.
Chapter 9
Network Security
Stateful versus stateless firewalls, packet filtering in practice, IPsec and WireGuard VPNs, zero-trust segmentation, and the categories of DDoS and how each is mitigated.
Chapter 10
Load Balancing and Proxies
Forward and reverse proxies, L4 versus L7 load balancing, algorithms and health checks, the three ways to handle TLS at the edge, and CDNs.
Chapter 11
Services and Observability
NTP and why clock skew corrupts everything downstream, the telemetry families that show you the network, packet capture, and the few signals worth alerting on.
Chapter 12
Performance and Troubleshooting
A layer-by-layer method, the connectivity and socket tools and how they lie, latency versus jitter versus loss, the Path MTU black hole, and the bandwidth-delay product.
Chapter 13
Modern and Cloud Networking
Cloud VPCs and security groups, VXLAN overlays and software-defined networking, container and Kubernetes networking, and the service mesh sidecar model.
Chapter 14
Best Practices and Anti-Patterns
Designing for failure with redundancy and multipath, the recurring anti-patterns that cause outages, a security hardening checklist, and planning capacity for growth.