What Really Happens When You Type a URL Into Your Browser

Typing a URL into a browser looks simple.

You enter:

https://example.com

and press Enter.

A few seconds later, a webpage appears.

But an enormous amount of work happened between those two events.

Let’s follow the journey.

Step 1: The Browser Parses the URL

The browser identifies several components:

https://example.com/products?id=10
│       │           │
│       │           └── Query parameters
│       └────────────── Host
└────────────────────── Protocol

The protocol is HTTPS.

The host is example.com.

The browser now needs to discover where that host is located.

Step 2: DNS Lookup

The browser needs an IP address.

It may check several caches before asking a DNS resolver.

Eventually, DNS can provide something like:

example.com → 93.184.216.xxx

The exact infrastructure can be more complicated, especially for large websites using CDNs.

Step 3: Establishing a Connection

The browser communicates with the destination server.

For HTTPS, secure communication requires TLS negotiation.

The browser and server establish cryptographic parameters before application data is exchanged securely.

Step 4: Sending the HTTP Request

The browser can now send something conceptually similar to:

GET /products HTTP/1.1
Host: example.com

Additional headers may include:

Accept
User-Agent
Cookie
Accept-Encoding

Step 5: The Server Processes the Request

The request might travel through several layers:

Browser
 ↓
CDN
 ↓
Load Balancer
 ↓
Reverse Proxy
 ↓
Application Server
 ↓
Database

The application might query a database and generate a response.

Step 6: The Response Returns

The server could return:

HTTP/1.1 200 OK
Content-Type: text/html

followed by HTML.

But the browser isn’t finished.

Step 7: HTML Becomes a Page

The browser parses the HTML and constructs the DOM.

Get The Lazy Developer’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

If the HTML contains:

<link rel="stylesheet" href="styles.css">
<script src="app.js"></script>

the browser must retrieve those resources too.

CSS is parsed into the CSSOM.

JavaScript is executed.

Images are downloaded.

Fonts may be downloaded.

Additional API requests may occur.

Step 8: Rendering

The browser combines the DOM and CSS information to determine what should appear on screen.

It calculates:

• Layout
• Dimensions
• Positioning
• Styles
• Painting
• Compositing

Eventually, pixels appear on your display.

Why Developers Should Understand This

Suppose a website feels slow.

You could simply say:

“The frontend is slow.”

But understanding the request lifecycle lets you ask better questions.

Is DNS slow?

Is the server responding slowly?

Is the database query inefficient?

Are images too large?

Is JavaScript blocking rendering?

Are there too many API requests?

Is the CDN configured correctly?

Performance debugging becomes much more systematic.

The Entire Journey

A simplified model looks like:

URL
 ↓
DNS
 ↓
Connection
 ↓
TLS
 ↓
HTTP request
 ↓
Server
 ↓
Application
 ↓
Database
 ↓
HTTP response
 ↓
Browser parsing
 ↓
Rendering
 ↓
Pixels

The next time you type a URL, remember:

You’re not simply opening a webpage.

You’re triggering a distributed system involving networking, security, operating systems, servers, databases, and browser rendering.

That’s what makes the modern web so interesting.