Typing a URL into your browser may feel instantaneous, but behind the scenes, a complex series of system-level interactions takes place. From resolving domain names to rendering pixels on your screen, this process involves multiple layers of networking, security, and application logic.
Understanding this flow is a fundamental system design concept and a common interview topic. Let’s break it down step by step.
Before making any network requests, the browser checks its local cache.
The browser looks for a previously stored response for the requested URL.
Cached resources may include HTML, CSS, JavaScript, images, and fonts.
Cache headers (Cache-Control, ETag, Expires) determine whether the cached content is still valid.
Using cached content avoids unnecessary network requests, significantly improving page load time and reducing bandwidth usage.
If the resource is not cached, the browser must find the server’s IP address.
The browser checks the OS cache and local DNS cache.
If not found, a request is sent to a DNS resolver.
The resolver queries DNS servers (root → TLD → authoritative) to resolve the domain name.
The resolved IP address is returned to the browser.
DNS translates human-readable domain names (e.g., example.com) into machine-readable IP addresses.
Once the IP address is known, the browser establishes a connection with the server.
A TCP three-way handshake occurs:
SYN
SYN-ACK
ACK
This creates a reliable communication channel between the client and server.
TCP ensures ordered, reliable delivery of data across the network.
If the URL uses HTTPS, a secure connection must be established.
The browser and server perform a TLS handshake.
The server sends its SSL/TLS certificate.
The browser verifies the certificate with a trusted Certificate Authority (CA).
Encryption keys are exchanged.
HTTPS ensures data confidentiality, integrity, and authenticity, protecting users from man-in-the-middle attacks.
With a secure connection in place, the browser sends an HTTP request.
The request includes:
HTTP method (GET, POST, etc.)
URL path and query parameters
Headers (cookies, user-agent, authorization)
The request is sent over the established TCP/TLS connection.
The HTTP request defines exactly what resource the browser is asking for and how the server should respond.
The server processes the request and returns a response.
The request may pass through load balancers, firewalls, and application servers.
The server executes application logic and queries databases if needed.
An HTTP response is sent back, containing:
Status code (200, 301, 404, 500, etc.)
Headers
Response body (HTML, JSON, etc.)
This step is where business logic runs and data is generated.
Finally, the browser turns the response into a visible webpage.
The browser parses HTML and builds the DOM.
CSS is parsed to create the CSSOM.
JavaScript is executed.
The DOM and CSSOM are combined to create the render tree.
Layout and painting occur to display pixels on the screen.
Efficient rendering determines how fast users see and interact with the page.
When you type a URL into your browser, a carefully orchestrated sequence of events occurs:
The browser checks its cache to avoid unnecessary work
DNS resolves the domain name to an IP address
A TCP connection is established
A secure HTTPS handshake protects communication
An HTTP request is sent to the server
The server processes the request and sends a response
The browser renders the response into a usable webpage
This end-to-end flow demonstrates how multiple system components—networking, security, and application layers—work together to deliver content in milliseconds. Understanding this process is essential for designing scalable, performant, and secure systems.