DEV Community: Elizabeth Omito

What Actually Happens When You Press Enter on a URL?

Elizabeth Omito — Sun, 15 Mar 2026 12:53:58 +0000

You open your browser, type a URL, and press Enter within a few milliseconds, a website appears on your screen.

But behind that simple action is a complex chain of events happening across the globe: servers communicating, routers forwarding packets, DNS translating names into numbers, and encrypted connections securing your data.

Every time you visit a website, your request might travel through dozens of networks, multiple countries, and thousands of miles of fiber-optic cables before the response returns to your device.

So what really happens when you load a website?

1. The Internet Is a Network of Networks

At its core, the internet is simply a massive global network of interconnected computers.
These networks include:

Home networks
Corporate networks
Data centers
Internet Service Providers (ISPs)
Global backbone infrastructure

Each device connected to the internet is identified by something called an IP address.
Example:
142.250.190.78

This number uniquely identifies a device on the internet, similar to how a home address identifies a house.

2. Domain Names vs IP Addresses

Humans aren’t good at remembering numbers. Instead of typing an IP address, we use domain names like:
google.com
github.com
dev.to

So how does your computer know the IP address of a domain?
This is where DNS (Domain Name System) comes in it works like the phonebook of the internet.

Example process:
User enters: dev.to
↓
Browser asks DNS server
↓
DNS returns: 151.101.1.195
↓
Browser connects to that server

3. What Happens When You Enter a URL

Let’s say you visit:
https://dev.to

Several things happen behind the scenes.
Step 1 — DNS Lookup

Your browser asks a DNS resolver:
“What is the IP address for dev.to?”

The resolver returns the server’s IP.

Step 2 — TCP Connection

Your browser establishes a connection to the server using TCP (Transmission Control Protocol).

TCP ensures:

Data arrives
Data arrives in order
Missing packets are retransmitted

This step is often called the TCP handshake.

Step 3 — HTTPS Encryption

If the site uses HTTPS (most do), the browser performs a TLS handshake.

This step:

Verifies the server’s identity
Establishes encryption
Protects the data being transmitted

Now your communication is secure.

Step 4 — HTTP Request

Your browser sends a request like this:

GET / HTTP/1.1
Host: dev.to

This is the HTTP protocol, which defines how browsers and servers communicate.

Step 5 — Server Response

The server processes the request and sends back a response:

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

Along with the HTML of the webpage.

Your browser then:

Parses the HTML
Downloads CSS
Downloads JavaScript
Renders the page
And the website appears on your screen.

4. How Data Travels Across the Internet

Data doesn’t travel as one big chunk. Instead, it is broken into small packets.

Each packet contains:

Source IP
Destination IP
Data payload
Packet number

Routers across the internet decide the best path for each packet to reach its destination.

Think of it like sending multiple envelopes through different postal routes that all arrive at the same house.

5. The Role of Servers and Data Centers

Websites live on servers inside data centers.

These servers run software like:

Web servers (Nginx, Apache)
Application servers
Databases

Large companies operate massive data centers around the world to ensure:

High availability
Low latency
Redundancy

6. CDNs Make the Internet Faster

To make websites load faster globally, companies use Content Delivery Networks (CDNs).

A CDN stores cached copies of content in servers located around the world.

Instead of requesting a file from a server in another continent, you may receive it from a nearby edge server.

This dramatically reduces latency.

7. A Simplified Flow

Here’s the entire process summarized:

User enters URL
DNS finds IP address
Browser establishes TCP connection
TLS handshake secures connection
Browser sends HTTP request
Server sends HTTP response
Browser renders the webpage

All of this typically happens in milliseconds.

Final Thoughts

The internet may seem complex, but at its core it’s built on a few fundamental ideas:

IP addresses identify devices
DNS maps names to IPs
TCP ensures reliable data delivery
HTTP allows browsers and servers to communicate

Understanding these layers helps developers:

Debug networking issues
Optimize performance
Build better distributed systems And once you see the mechanics behind it, the internet becomes a lot less mysterious.

What Working With Git Actually Taught Me About Collaboration

Elizabeth Omito — Mon, 23 Feb 2026 22:37:18 +0000

When I first learned Git, I saw it as a set of commands:

git add
git commit
git push
git pull

It felt procedural — just steps to move code around but once I started working on real projects, I realized Git isn’t just version control. It’s structured collaboration.

1. Commit Messages Are Communication
At first, my commits looked like this:
“update”
“fix”
“changes”

Later, I understood that commit messages are part of the project’s history. A good commit message answers:
What changed?
Why did it change?

Clear commits make it easier for teammates (and future you) to understand the evolution of the codebase.

2. Pull Before You Push
One practical lesson that stuck with me:
Always git pull before git push.
Not doing this led to conflicts and unnecessary friction. Pulling first ensures you’re building on the latest version of the project, not overwriting someone else’s work.

It’s a small habit with big impact.

3. Merge Conflicts Aren’t Errors — They’re Signals
The first time I saw a merge conflict, it looked like the code was broken but technically, Git was doing exactly what it’s designed to do:
It detected overlapping changes and paused the merge to let me resolve them intentionally.

Conflicts aren’t failures. They’re checkpoints that force alignment.

4. Smaller Changes Reduce Risk
Large, unstructured commits make reviewing and merging harder.
Breaking work into smaller, focused commits makes collaboration smoother and debugging easier.

This changed how I structure my work.

What I Learnt From My First Go Project: Go Reloaded

Elizabeth Omito — Fri, 06 Feb 2026 13:48:39 +0000

When I first started learning Go, I thought I understood the language.
I knew the syntax, I knew the logic, and I thought writing small programs would be easy.
Then I started Go Reloaded.

What Go Reloaded Was
Go Reloaded was my first “real” project in Go — not just following tutorials, but actually building something and making it work.
It was simple on the surface: output formatting, string handling, and writing a few functions.
But simple turned out to be deceptively hard.

The Moment I Got Humbled
I thought my code was perfect… until I ran the tests.
The output I got was:

it was the best of Times , it was the worst of TIMES,

whereas the expected output was:

It was the best of times, it was the worst of TIMES,

One tiny comma. One small space. And the test failed.

It was frustrating, but it taught me something crucial: precision matters. Computers don’t guess what you meant — they only care what you actually wrote.

What I Learned
From Go Reloaded, I learned:
-Small mistakes, like punctuation or spaces, can break everything.
-Writing code carefully matters more than writing it fast.
-Debugging is as much about reading the test as reading the code.
-It was humbling, yes, but also exciting. Each mistake became a lesson.

This project set the tone for all my future Go work. After Go Reloaded:
-I started reading test failures carefully.
-I paid more attention to formatting and data handling
-I became more patient and methodical

Go Reloaded was more than just code — it was my first taste of learning in public.

Final Thought
Sometimes the smallest projects teach the biggest lessons.
Go Reloaded taught me to slow down, pay attention, and embrace the little mistakes because that’s where growth happens.