---
topic: network-protocols
author: Crashtech Editorial
published: Nov 15, 2026 · read: 5 min
---

One Request Across the Network: DNS, TCP or QUIC, TLS, HTTP, and WebSockets

Trace how application data crosses name resolution, transport, encryption and protocol layers—and correct common shortcuts about UDP, QUIC and DNS.

– –
A sealed message passes through labeled physical, network, transport, security and application gates on its way to a service.
Conceptual protocol-layer view; the gates are not a literal packet format.

When an API call fails, “the network is down” hides several different failure surfaces. DNS may return an address, transport may establish a connection, TLS may authenticate and encrypt the peer, and HTTP may still return an application error. Debugging improves when each layer is treated as a separate contract and when diagrams avoid claims such as “UDP has no congestion control” or “TLS 1.3 is always zero round trip.” The standards define narrower behavior. [1] [2] [3] [4] [6] [7]

Follow one request

A new HTTPS connection can be sketched this way; browsers can reuse a prior connection, and HTTP/3 follows a different transport path:

hostname → DNS answer (possibly cached)
         → transport connection: TCP for HTTP/1.1 or HTTP/2,
                                 QUIC for HTTP/3
         → TLS security negotiation (TLS over TCP, integrated with QUIC)
         → HTTP request and response

This is a conceptual dependency order, not a guarantee that each item produces a distinct network round trip. DNS caches may satisfy resolution locally; TLS session resumption and QUIC connection setup have additional rules; a reused connection can carry more than one application request.

DNS: names and cached answers

DNS is a distributed naming system. The client or its resolver uses cached records where available and otherwise follows the resolver’s process to obtain an answer. DNS is not necessarily contacted for every HTTP request. A response also has a time-to-live that influences caching; when an address changes, resolvers and clients can continue to use a cached answer until its policy permits refresh. That makes DNS useful for discovery and broad steering, but not equivalent to immediate per-request failover. [1] [2]

TCP and UDP: different transport contracts

TCP provides a reliable, ordered byte stream with mechanisms for sequence tracking, retransmission and congestion control. Applications use the stream; they do not see message boundaries preserved automatically. [2]

UDP provides a datagram transport with much less built-in connection state. It does not provide TCP-style delivery guarantees or ordering. That does not mean a UDP application may ignore congestion: higher-level protocols that send over UDP must still use suitable congestion behavior. QUIC supplies that richer transport behavior while using UDP datagrams as its substrate. [3] [4]

QUIC, TLS and HTTP/3

QUIC is a secure, connection-oriented transport. It defines streams, flow control, connection IDs and path migration, along with loss detection and congestion control. QUIC version 1 integrates with TLS for key negotiation through a companion specification; HTTP/3 maps HTTP semantics onto QUIC streams. [4] [5] [7]

The combination can avoid TCP’s cross-stream transport-level head-of-line blocking when a packet is lost, because independent QUIC streams can make progress separately. This is not a claim that HTTP/3 eliminates all latency or loss effects: congestion, packet loss, server work, network path and application dependencies still matter.

TLS 1.3 defines handshake and security behavior. 0-RTT is an optional resumption mode; early data can be replayed under some threat scenarios, so applications must consider whether an operation is safe to repeat. “TLS 1.3 means every new connection takes one round trip” and “TLS is zero round trip” are both imprecise shorthand. [5] [6]

HTTP and WebSockets: application protocols

HTTP defines request/response semantics and evolves across versions. A browser can use HTTP/1.1 or HTTP/2 over TCP with TLS, and HTTP/3 over QUIC. Which protocol is negotiated depends on client, server and network support. The application sees HTTP messages, not the lower-layer retransmission schedule. [7]

WebSocket begins with an HTTP handshake and then upgrades the connection to a bidirectional framing protocol. It is useful when both sides need to send messages over a persistent connection. Server-Sent Events instead provide a one-way stream from server to client over HTTP. The decision depends on message direction, reconnect behavior, infrastructure support and operational limits, not a universal “faster” label. [8]

A practical debugging ladder

When a request fails, locate the earliest layer that can explain the evidence:

  1. Name resolution: Which resolver answered? Was the result cached? Is the returned address expected?
  2. Reachability and transport: Did a TCP or QUIC connection establish? Are resets, timeouts or packet loss visible?
  3. Security: Did certificate validation and the TLS/QUIC handshake succeed? Does the hostname match?
  4. Application protocol: Was HTTP negotiated? What status, headers and body returned? Did a WebSocket upgrade complete?
  5. Service behavior: Did the backend, authentication, rate limit or dependency produce the failure?

Capture timestamps and connection reuse state; otherwise a log line saying “DNS resolved” may refer to a lookup performed minutes earlier, while the failed request reused an existing socket. Network paths, client libraries, proxies and load balancers can alter where a failure appears.

For a related boundary decision, see our cloud load-balancer guide. A load balancer can route at different layers, but it does not erase the protocol distinctions underneath.

Do

  • Identify the protocol and connection state before assigning a failure to a layer.
  • Treat DNS caching, connection reuse, and QUIC/TLS setup as explicit variables in measurements.
  • Read the relevant RFC when handshake, delivery or replay semantics affect a design.

Don't

  • Do not describe UDP as permission to ignore congestion control.
  • Do not equate QUIC with plain UDP or say TLS 1.3 is universally zero round trip.
  • Do not assume every request performs a fresh DNS lookup and connection handshake.

Protocol layers make the request path easier to reason about when each layer’s responsibility stays precise. That precision turns vague outage reports into questions an engineer can test.

Advertisement

Frequently asked questions

Does DNS happen before every HTTP request?

A client generally needs an address for a hostname before establishing a new connection, but caches can reuse DNS answers and an existing connection can carry additional requests without a new lookup.

Is UDP an unreliable protocol with no congestion control?

UDP itself provides datagrams without TCP-style connection setup, ordering or retransmission. Applications using UDP still need congestion-control behavior appropriate to their protocol; QUIC supplies transport mechanisms over UDP.

Is QUIC just UDP with encryption?

No. QUIC is a secure, connection-oriented transport with streams, flow control, loss detection, congestion control and path migration. QUIC version 1 uses TLS integration defined in a companion specification.

Does TLS 1.3 make a connection zero round trip?

A regular TLS 1.3 handshake has its own handshake flight pattern; 0-RTT data is an optional resumption feature with replay considerations. HTTP/3 uses QUIC, which integrates TLS 1.3, so its connection setup should be analyzed as a combined protocol path.

Sources & further reading

/* Comments */