A protocol is a formal set of rules that defines how two systems format, transmit, sequence, and acknowledge data so both ends interpret the same bytes identically. A network protocol specifies message syntax, timing, error handling, and the state each side must track. Without a shared protocol, two machines pushing bytes at each other have no agreement on what those bytes mean. The modern web stacks several of them: DNS resolves a name, TCP or QUIC opens a connection, TLS 1.3 encrypts it in a single round trip, and HTTP/3 (RFC 9114, 2022) carries the request — four protocols cooperating before one byte of content arrives.
A protocol turns an arbitrary stream of bits into a conversation with grammar. It answers three questions that both endpoints must agree on before communication succeeds: syntax (what does a valid message look like), semantics (what does each field mean and what response does it demand), and timing (in what order and within what window must messages arrive). Change any of the three unilaterally and the connection breaks.
Most protocols also carry state. TCP tracks sequence numbers, window sizes, and connection phase; TLS tracks handshake progress and session keys; HTTP/2 and HTTP/3 track stream IDs and flow-control credits. That state is what lets a protocol recover from loss, reorder packets, and multiplex many logical streams over one physical link.
A network protocol works by exchanging framed messages that follow a shared state machine, with each side validating headers, updating local state, and acknowledging progress. Take a TCP handshake: the client sends SYN, the server replies SYN-ACK, the client returns ACK, and only then does the connection move to the ESTABLISHED state where data may flow.
Layering keeps this manageable. Each protocol solves one problem and hands its payload to the next: IP handles addressing and routing, TCP or QUIC handles reliability and ordering, TLS handles encryption, and an application protocol like HTTP defines the request-response semantics. A byte of a video segment is wrapped, unwrapped, and reinterpreted at every boundary.
Protocols split roughly by the job they do. The categories below are the ones an engineer touches most often.
The single most useful takeaway: a network protocol is chosen by its guarantees, not its speed — you pick UDP-based QUIC over TCP for lossy links because head-of-line blocking, not raw bandwidth, is the real bottleneck.
HTTP/3, standardized as RFC 9114 in 2022, replaces TCP with QUIC over UDP and cuts connection setup to a single round trip — or zero on session resumption — while removing the transport-level head-of-line blocking that slowed HTTP/2 on networks with 1–2% packet loss. For content delivery, that protocol change shortens time to first byte on mobile and long-haul routes without touching application code.
Protocol vs. API: A protocol defines how bytes move on the wire between systems; an API defines how a program calls functionality within or across services. gRPC is an API framework that runs over the HTTP/2 protocol — the two operate at different layers of the same request.
Protocol vs. standard: A standard is a published, ratified specification (an RFC, an IEEE document); a protocol is the rule set that a standard describes. Every well-known protocol is defined by a standard, but internal or proprietary protocols can exist with no public standard at all.
Protocol vs. interface: An interface is the contract a component exposes to its caller; a protocol is the conversation between two independent parties across a boundary. A socket is an interface; TCP is the protocol you speak through it.
ALPN (Application-Layer Protocol Negotiation) lets client and server agree on the application protocol during the TLS handshake. This curl call forces HTTP/3 and prints the negotiated version:
curl --http3 -sI https://example.com \
-w "negotiated: %{http_version}\n" -o /dev/nullA response of negotiated: 3 confirms the endpoint speaks HTTP/3; 2 means it fell back. The alt-svc response header is what advertised HTTP/3 availability to the client in the first place.
"HTTP and HTTPS are different protocols." HTTPS is not a separate protocol; it is HTTP carried inside a TLS-encrypted channel. The application semantics are identical.
"A faster protocol always means a faster site." HTTP/3 helps most on lossy or high-latency links. On a clean, low-latency connection, the gain over HTTP/2 is often within measurement noise.
"UDP is unreliable, so serious systems avoid it." QUIC, DNS, and most real-time media run over UDP. Reliability is a property you add in a higher protocol layer when you need it, not a fixed trait of the transport.
A protocol is an agreed set of rules that lets two systems exchange data reliably by defining message format, order, and error handling. Both sides implement the same rules, so a byte sent by one is interpreted identically by the other. It is the shared grammar that turns raw bits into meaningful communication.
A protocol is any rule set for structured exchange, including offline contexts; a network protocol specifically governs data transmitted across a network, adding addressing, routing, reliability, and timing. In practice, engineers use "protocol" and "network protocol" interchangeably when discussing TCP, HTTP, DNS, and similar wire-level rule sets.
The most common network protocols in 2026 are IP, TCP, UDP, QUIC, TLS 1.3, DNS, and the HTTP family (HTTP/1.1, HTTP/2, HTTP/3). Web traffic typically combines DNS for resolution, QUIC or TCP for transport, TLS for encryption, and HTTP for application semantics within a single request.
Protocols use layers so each one solves a single problem and can evolve independently. IP handles routing, TCP or QUIC handles reliability, TLS handles encryption, and HTTP handles request semantics. Because layers expose stable boundaries, HTTP/3 could swap TCP for QUIC without rewriting DNS, TLS, or application logic.
Run the ALPN check above against your own origin and edge, then compare time to first byte on HTTP/2 versus HTTP/3 from a mobile network with real packet loss — that is where the protocol difference actually shows. If HTTP/3 negotiation fails, inspect the alt-svc header and your UDP path before blaming the client. For a deeper reference on how transport and application protocols shape delivery performance across providers, compare the mechanics in this CDN protocol and delivery comparison, then instrument the metric that matters for your traffic.