Common network protocols every engineer should know
The dozen protocols that quietly carry every request you make, sorted by the layer they live on.
Networking is a stack of protocols, each solving one job and building on the one below. At the application layer sit HTTP/HTTPS, DNS, DHCP, SMTP/IMAP, FTP/SFTP, SSH and WebSocket; the transport layer offers TCP (reliable) and UDP (fast); the network layer has IP (addressing) and ICMP (diagnostics); and the link layer uses ARP to map IP addresses to hardware. Knowing which protocol does what, and where it sits, is core networking literacy.
HTTP / HTTPS — the web
HTTP (Hypertext Transfer Protocol) is the application-layer request-response protocol that carries web pages and APIs. HTTPS is the same protocol wrapped in TLS, so the traffic is encrypted, tamper-evident and authenticated. Both are L7 and ride on top of TCP; nearly everything you do in a browser is one of these.
DNS / DHCP — names and addresses
DNS (Domain Name System) is the L7 lookup service that translates a human name like example.com into an IP address. DHCP (Dynamic Host Configuration Protocol) is what automatically assigns your device an IP address, gateway and DNS server the moment it joins a network. Together they let you use names and join networks without hand-configuring anything.
Mail, files, and remote shells
SMTP sends and relays email between servers, while IMAP lets a client read and manage mail stored on a server. FTP transfers files but sends credentials in the clear, so SFTP — file transfer tunneled over SSH — is the secure replacement. SSH (Secure Shell) itself gives you an encrypted remote command line and secure tunneling. All are L7 application protocols.
WebSocket — live two-way
WebSocket is an L7 protocol that starts as an HTTP request and upgrades the connection into a persistent, full-duplex channel. Once established, client and server can send messages to each other at any time with very little overhead. It's the backbone of chat apps, live dashboards and multiplayer games where plain request-response isn't enough.
TCP / UDP — the transport layer
TCP (Transmission Control Protocol) provides a reliable, ordered, connection-oriented byte stream — it handshakes, retransmits lost data and guarantees order, which is why the web, email and file transfer sit on it. UDP (User Datagram Protocol) fires off datagrams with no handshake and no guarantees, trading reliability for speed, which suits DNS queries, video calls and gaming. Both are L4, sitting between the applications above and IP below.
IP / ICMP / ARP — addressing and delivery
IP (Internet Protocol) is the L3 addressing and routing layer that gives every device an address and moves packets hop by hop toward their destination. ICMP is IP's helper for diagnostics and error reporting — it's what ping and traceroute use. ARP (Address Resolution Protocol) works down at L2, mapping an IP address to the physical MAC address of the device on the local network so the packet can actually be delivered.
Why networking is a stack of protocols
No single protocol runs the internet. Instead, networking is built as a stack of layers, each solving one narrow problem and relying on the layer beneath it. When you load a web page, HTTP handles the request for the page, but it doesn't know or care how the bytes actually cross the world — it hands that to TCP, which guarantees the bytes arrive intact, which in turn hands packets to IP to be addressed and routed, which relies on the link layer to physically move them across each hop. Each layer treats the one below as a service it can call and the one above as a customer it serves.
This layering is the single most important mental model in networking, because it lets you reason about one problem at a time and swap pieces independently. HTTPS is just HTTP with an encryption layer slipped underneath; HTTP/3 replaced TCP with QUIC without changing what HTTP means. The protocols below are the ones you meet constantly as an engineer, grouped by the layer they occupy — application (L7), transport (L4), network (L3), and link (L2). You don't need to memorize their internals, but knowing what each does and where it sits turns "the network is down" into a set of specific, checkable questions.
The application layer: HTTP, HTTPS, DNS, DHCP
The application layer is where protocols speak in terms your software cares about. Four are foundational to everyday systems:
- HTTP (Hypertext Transfer Protocol) is the request-response protocol of the web and of most APIs. A client sends a request (a method like
GETplus a URL and headers) and the server returns a status code and a body. It underpins nearly everything a browser or mobile app does. - HTTPS is not a different protocol so much as HTTP running inside TLS, which encrypts the traffic, verifies you're talking to the real server, and detects tampering. It is now the default for essentially all web traffic.
- DNS (Domain Name System) is the internet's phone book. Humans use names like
example.com; machines route on IP addresses. DNS is the distributed lookup service that resolves one to the other, and it typically runs over UDP for speed. - DHCP (Dynamic Host Configuration Protocol) is what lets a device just join a network and work. When your laptop connects to Wi-Fi, DHCP automatically leases it an IP address and tells it the default gateway and DNS servers to use, so nobody has to configure addresses by hand.
More application protocols: mail, files, shells, sockets
Beyond the web, several other application-layer protocols show up constantly:
- SMTP (Simple Mail Transfer Protocol) is the protocol for *sending* email — your mail client uses it to submit a message, and mail servers use it to relay messages to each other.
- IMAP (Internet Message Access Protocol) is for *reading* mail: it lets a client view and manage messages that stay stored on the server, synced across devices. (Its older sibling POP3 downloads and removes mail instead.)
- FTP (File Transfer Protocol) moves files between machines but sends credentials and data unencrypted, so it's considered insecure. SFTP is the modern replacement — file transfer carried securely over an SSH connection.
- SSH (Secure Shell) provides an encrypted remote terminal into another machine, plus secure tunneling and key-based authentication. It's how engineers administer servers safely, and it's the transport SFTP rides on.
- WebSocket starts as an HTTP request that *upgrades* the connection into a persistent, full-duplex channel, letting server and client exchange messages freely in real time. It powers chat, live feeds and collaborative apps where plain request-response falls short.
Every one of these is an L7 protocol, and every one of them ultimately relies on the transport layer beneath to actually deliver its bytes.
The transport layer: TCP vs UDP
Underneath every application protocol sits the transport layer, and it offers a stark choice between two philosophies.
TCP (Transmission Control Protocol) is connection-oriented and reliable. Before any data flows, it performs a three-way handshake to establish a connection, then guarantees that bytes arrive in order and intact, retransmitting anything lost and controlling its sending rate to avoid overwhelming the network. This reliability is why HTTP, email, SSH and file transfer all ride on TCP — for a web page or a file, a missing chunk is unacceptable. The cost is overhead and latency: the handshake and the ordering guarantees add round-trips and buffering.
UDP (User Datagram Protocol) is connectionless and unreliable by design. It just fires off independent datagrams with no handshake, no ordering, and no retransmission. That sounds worse, but for the right workloads it's exactly right: DNS lookups (one small query, one small answer), live video and voice calls, and online games all prefer UDP because speed matters more than perfect delivery — a retransmitted video frame from half a second ago would arrive too late to be useful anyway. The rule of thumb: choose TCP when every byte must arrive, choose UDP when timeliness beats completeness.
The network and link layers: IP, ICMP, ARP
Below transport, the network and link layers handle the actual job of getting packets from one machine to another across the world.
IP (Internet Protocol) is the layer that makes the internet an *inter*-net. It gives every device an address (IPv4 like 192.0.2.10, or the much larger IPv6 space) and defines how packets are routed hop by hop, each router forwarding a packet one step closer to its destination based on the address. IP itself is "best-effort" — it makes no promise a packet will arrive, which is precisely why TCP exists on top to add the guarantees.
ICMP (Internet Control Message Protocol) is IP's diagnostic companion. It carries control and error messages rather than user data — "destination unreachable," "time exceeded," and the echo requests and replies that the ping and traceroute tools use to test reachability and measure latency. When you ping a server, you're speaking ICMP.
ARP (Address Resolution Protocol) operates at the link layer, solving the last-mile problem: on a local network, a device needs the physical hardware address (the MAC address) of the next hop, not just its IP. ARP broadcasts "who has this IP?" and the owner replies with its MAC, so the packet can be framed and physically delivered on the local segment. It's the quiet translator that connects the logical world of IP addresses to the physical world of network cards. Together these three layers turn an application's stream of bytes into signals that actually reach the right machine — and knowing this whole stack is what lets you debug problems at the right layer instead of guessing.
Protocols are layered: application (L7) rides on transport (L4), which rides on network (L3) and link (L2).
HTTP/HTTPS carry the web; HTTPS is just HTTP wrapped in TLS encryption.
DNS resolves names to IPs; DHCP automatically hands out IP addresses to devices joining a network.
TCP gives reliable, ordered delivery; UDP gives fast, connectionless delivery with no guarantees.
SMTP sends mail, IMAP reads it; FTP transfers files and SFTP does it securely over SSH.
IP addresses and routes packets, ICMP reports errors (ping), and ARP maps IP addresses to MAC addresses.
Quick quiz
Which pair correctly matches a protocol to its layer?
You need low latency for a live video call and can tolerate occasional lost frames. Which transport protocol fits?
Common ports worth knowing
The port numbers that tell you which service is listening — memorize these and half of networking clicks.
TCP vs UDP
Reliable and ordered, or fast and best-effort — the transport trade-off.
How DNS works
Turning a human name into a machine address by walking a global hierarchy.
How HTTPS works
The TLS handshake that turns a plain TCP connection into a private, verified channel.