Understanding the Need for Version Control: Solving the Pendrive Problem

Shubham Prasad — Thu, 29 Jan 2026 02:24:29 +0000

The Pre–Version Control Era

Before Git, before GitHub — even before stable internet — writing software as a team was messy.

Imagine you and your friend Sid building your dream project. No internet. No cloud.

Just two laptops and a pendrive.

You write your part, zip the folder, copy it to the pendrive, travel to Sid’s place.

Sid writes his part, saves, and hands the pendrive back.

You return home, open the project… and something has changed.

But you don’t know:

what changed
where it changed
who changed it

You ignore it because the project still works.

Until the next day — when a bug appears.

Now you're stuck:

If you fix it, you might overwrite Sid’s work.
If Sid fixes something later, he might overwrite yours.

This is where development turns into chaos.

The “Brilliant” Fix You and Sid Invent

Since both of you are smart, you create a clever system:

You start making new folders for every change.

For a moment, this feels genius.

Then reality hits:

the project size explodes
you forget which folder contains which change
both of you edit different copies
merging becomes impossible
adding even one more teammate breaks everything instantly

Your “system” collapses the moment more than one person works at the same time.

The Real Problems

1. No visibility

You can’t see what changed, when it changed, or who did it.

2. No reliable history

If a bug appears, there’s no clean way to go back to a working version.

3. Risk of overwriting

One person’s work can silently erase another’s.

4. No parallel work

Only one person can work safely at a time.

5. Slow, painful development

Everyone waits for everyone else → progress dies.

This isn’t a small inconvenience.

This is a fundamental blocker to building software as a team.

Trying to Imagine a Better System

Developers around the world wondered:

“What if we had a system that tracks changes the way a time tracker logs start and end times?”

A system that could:

record every change
know who made it
let us go back to any past version
prevent overwriting
allow teams to work at the same time

But that raised more questions.

How do we store these changes?

In files? In a custom database? Something fast but reliable?

How do we prevent history tampering?

Maybe only allow changes through specific commands.

How do teams collaborate from different places?

Host this “change tracker” online so every developer can sync updates.

This idea — the idea of tracking and organising changes — evolved into…

What Is a Version Control System?

Version Control is simply:

A system that records every change to your files so you can revisit any version later.

Tools like Git, Mercurial, Subversion, and Perforce all follow this idea.

At their core, they’re extremely smart trackers.

They solve the pendrive problems:

lost work
overwritten files
no history
no safe collaboration

Why Version Control Became Essential

Imagine the same pendrive chaos inside a real company with:

10… 50… or hundreds of developers.

Everyone pushing code, fixing bugs, adding features, and moving fast.

If even two people overwrite each other, the entire project can break.

If a bug appears and no one knows who changed what, teams can lose days.

As software grew bigger and teams became global, this chaos became impossible to manage.

Version control didn’t become popular because developers wanted it.

It became popular because without it, modern software would collapse.

Git, in particular, became the backbone because it offered:

complete history
safe collaboration
powerful branching
extremely fast operations
a design that makes rewriting history almost impossible

It didn’t just help teams — it made today’s software ecosystem possible.

Can You Build Your Own VCS?

Surprisingly: yes.

At its core, a VCS is just:

a way to track changes
a way to store history
a way to sync updates

You could build a simple one with:

a database
some hashing
some diff storage
a small server to sync changes

Different VCS tools do exactly this — they just implement these ideas differently.

The idea is simple.

The engineering is not.

That’s why developers rely on mature systems like Git, which have already solved all the tricky parts.

What’s Next?

Version control isn’t just a tool — it’s a concept.

A concept built so developers can:

track every change
preserve clean history
collaborate without fear

In the next article, we’ll look at Git — the most widely used VCS today.

We’ll cover:

how Git stores your changes
what makes Git so fast
the essential commands you’ll actually use

And no — GitHub isn’t Git.

It’s just a hosting platform.

See you in the next one.

Connect with me on LinkedIn and X

Forem: Shubham Prasad