Networking

A TLS handshake extension that negotiates the application protocol (like HTTP/2 vs HTTP/1.1) during the secure handshake itself — saving a round trip and enabling HTTP/2 on the web.

AWS's CDN: hundreds of edge locations caching your content near users, tightly integrated with S3 and the AWS security stack — with cache-hit ratio as the metric that decides everything.

AWS's DNS service with a 100% availability SLA — where routing policies and health checks turn name resolution into a load-balancing and failover layer.

One IP address announced from many locations, with the network routing each user to the nearest — the backbone of CDNs, global DNS, and DDoS absorption.

Google Cloud's enterprise API management platform — heavyweight gateway plus developer portal, analytics, and monetization, priced and positioned for large API programs.

A Layer-7 proxy routing HTTP/HTTPS request payloads dynamically based on content paths and headers.

A dedicated physical circuit from your data center into AWS — consistent latency and lower per-GB egress in exchange for weeks of provisioning and real commitment.

Private, one-way connectivity to services across VPCs and accounts via interface endpoints — traffic that never touches the public internet or requires network peering.

A secure network service mapping endpoint targets privately inside a local subnet via network interface cards.

The routing protocol that ties the internet's ~75,000 independent networks together — deciding how traffic finds its way between them. Foundational, trust-based, and famously fragile.

Deciding when cached data is stale and must be refreshed or removed — famously one of computing's two hardest problems, because serving wrong data and re-fetching too often both hurt.

The slash notation that defines IP address ranges — and the one networking decision that becomes permanent the moment two networks need to talk.

Google Cloud's dedicated private connection between on-premises and GCP — the GCP equivalent of AWS Direct Connect and Azure ExpressRoute, in Dedicated and Partner flavors.

HashiCorp's multi-purpose tool for service discovery, health checking, a distributed key-value store, and service mesh — the connective tissue for services across VMs, clouds, and Kubernetes.

A distributed network of edge servers that caches content closer to users.

The service that automatically hands out IP addresses and network config to devices when they join a network — so you don't configure every device by hand. Invisible until it breaks.

An AWS component that lets one Direct Connect private link reach VPCs in many regions and accounts — so you don't need a separate physical connection per region. The hub for private AWS connectivity.

Direct Server Return — load-balanced requests arrive via the balancer, but responses bypass it entirely, straight from server to client. Huge asymmetric-traffic win, real operational sharp edges.

The time window required for global DNS servers to update cached records with new IP targets.

The system that translates human-readable domain names into IP addresses.

A cache placed at CDN edge locations near users, so content is served from a nearby city instead of a distant origin — the core mechanism that makes CDNs fast.

A markup language that lets a CDN assemble a page from separately-cached fragments — caching the static shell aggressively while fetching only the dynamic bits. Powerful but niche and quirky.

A high-performance L7 proxy built for cloud-native networking — the data plane inside most service meshes and many API gateways, handling routing, load balancing, retries, and observability.

Azure's dedicated private connection between on-premises and Azure — the Azure equivalent of AWS Direct Connect. Bypasses the public internet for consistent bandwidth, low latency, and compliance.

A DNS routing policy that sends all traffic to a primary endpoint and automatically switches to a standby only when the primary fails a health check — active-passive disaster recovery at the DNS layer.

DNS that answers differently based on where the query comes from — routing users to the nearest or most appropriate region at the resolution layer.

The major HTTP upgrade that added multiplexing, header compression, and server push over a single connection — a big performance win over HTTP/1.1, itself now succeeded by HTTP/3.

The latest HTTP version, running over QUIC (a UDP-based transport) instead of TCP — eliminating head-of-line blocking and speeding up connection setup, especially on flaky mobile networks.

The 'is this host reachable and how fast?' tool — ping uses ICMP echo request/reply to test connectivity and measure round-trip time. Ubiquitous for diagnostics, and often blocked or rate-limited.

Traffic direction from your network's point of view — a vocabulary distinction that decides real money, because clouds let data in free and charge for every byte leaving.

The VPC component that makes two-way internet connectivity possible — horizontally scaled, free, and meaningful only through routing and public IPs.

An encrypted tunnel that securely connects two networks over the public internet at the IP layer — the classic technology behind site-to-site VPNs linking offices, data centers, and cloud VPCs.

The internet running out of unique IPv4 addresses years ago — the scarcity that gave us NAT, carrier-grade NAT, IP markets, and the slow push toward IPv6.

The vastly larger 128-bit address system built to replace IPv4, whose ~4 billion addresses ran out years ago. Adoption is real but slow because of workarounds like NAT.

A service mesh that moves inter-service networking — mTLS, retries, traffic splitting, telemetry — out of application code and into a uniform infrastructure layer.

Reusing one TCP (and TLS) connection for many requests — the difference between paying handshake latency once and paying it on every call.

An API object managing external application access to services inside a Kubernetes cluster.

An infrastructure layer managing secure, observable service-to-service cluster communication.

A DNS routing policy that sends each user to whichever region will respond fastest for them — improving performance for globally distributed apps. Routes by network latency, not geography.

The negotiation protocol that bonds multiple physical links into one logical pipe — more aggregate bandwidth and instant failover, with per-flow hashing as the catch.

A lightweight, security-focused service mesh for Kubernetes — deliberately simpler than Istio, using its own ultralight Rust micro-proxy to give mTLS, observability, and reliability with minimal overhead.

Distributes incoming traffic across multiple servers or containers.

The hardware address burned into a network interface — used to deliver frames on the local network segment. Layer 2's addressing, distinct from the IP addresses that route globally.

Managed outbound-only internet access for private subnets — and the quietly notorious line item on cloud bills, at $0.045 per gigabyte processed.

A high-performance Layer-4 proxy routing TCP/UDP connections at ultra-low latency.

The veteran TLS-based VPN — runs anywhere, traverses anything, configurable to a fault — now the incumbent that WireGuard is steadily retiring.

The link-state interior routing protocol: every router learns the full network map and computes shortest paths — instant convergence math in exchange for design discipline.

Capping how many requests a client can make in a window — the fundamental control that protects APIs from abuse, overload, and runaway costs.

A server that sits in front of backend apps and forwards client requests to them.

A DNS routing policy redirecting query lookups to regions providing the lowest round-trip latency.

The per-subnet decision list that determines where packets go — the actual mechanism behind 'public' and 'private' in cloud networks.

How services find each other's current network locations in a dynamic environment where instances constantly appear, move, and disappear — the phone book for microservices.

The live directory at the heart of service discovery — a constantly-updated database of which service instances exist and where. Powerful, and a single point of failure if you let it be.

A TLS handshake extension that tells the server which hostname the client wants — so one IP can host many HTTPS sites with different certificates. Also a privacy leak TLS is now closing.

A slice of a VPC bound to one availability zone — the unit where routing, exposure, and blast radius are actually decided.

The bitmask that splits an IP address into network and host portions — the arithmetic beneath every CIDR block, subnet, and routing decision.

The methodology partitioning IP spaces into smaller, isolated networks using subnet mask notation.

The layered protocol family carrying essentially all internet traffic — and the layer model that tells you where latency, drops, and mysterious hangs actually live.

Skipping the full TLS negotiation on reconnection by reusing prior session keys — the optimization behind fast repeat HTTPS connections, culminating in TLS 1.3's 0-RTT.

A cloud hub-and-spoke router connecting multiple virtual networks, on-premises environments, and accounts.

An open-source API gateway written in Go — full-featured rate limiting, auth, and versioning without an enterprise paywall around the core.

The lightweight, connectionless transport protocol — fast and low-overhead, but with no delivery guarantees, ordering, or congestion control. The right choice when speed beats reliability.

An isolated virtual network inside a public cloud where you control IP ranges and routing.

Encrypted tunnels over public networks — site-to-site links that stitch clouds to data centers, and the remote-access model zero trust is busily replacing.

A private doorway that lets resources in your VPC reach AWS services (like S3) over Amazon's internal network instead of the public internet — more secure, and it can save on data costs.

A private link that merges routing between two VPCs — simple and free of hourly charges, but non-transitive by design, which is where every peering architecture eventually hurts.

A point-to-point network route enabling private communication between two virtual networks using internal IPs.

A protocol for a persistent, two-way connection between browser and server — real-time, low-overhead, bidirectional. The right tool for chat and live collaboration; overkill for one-way updates.

A DNS routing policy that splits traffic across endpoints by percentages you set — the mechanism behind gradual rollouts, A/B tests, and controlled migrations between environments.

The modern VPN protocol that made its predecessors feel obsolete — tiny codebase, kernel-speed, effortless roaming — and the engine under most 2026 mesh-networking products.