Why Version Control Exists: The Pendrive Problem

Ever wondered why do we have to use git?
Well, I did.
At first, I thought we could simply not use Git and still get work done. And to some extent, this is true for a single developer. But the moment you start working in a team, things go out of hand very quickly.

Life before version control

Before tools like Git became standard, developers still had to write code, share it, and collaborate.
But they didn’t have commit history, branches, backups, or any proper way to track collaboration.

So they used whatever was available at that time.

The Pendrive Analogy (very real)

Imagine this sitaution.

You are working on a project with 2-3 people.

There is one pendrive, one latest version of code.

The workflow looks like this:

1. Person A writes some code

2. Copies it to a pendrive

3. Gives the pendrive to Person B

4. Person B edits the code

5. Pendrive goes back to Person A

Sounds simple — until it breaks.

The “final”, “final_v2”, “latest_final“ problem

Very quickly, folders start looking like this:

At this point, no one knows which folder is correct, no one remembers what changed where, who changed what and everyone is afraid to delete anything.

What Problems Did This Cause?

1. Overwriting Someone Else’s Work

Two people edit the same file.

Person A:

• Updates logic

• Saves and shares

Person B:

• Was working on an older version

• Saves and sends back

Result:

• Someone’s work is gone

• No way to recover it

2. No Way to Go Back in Time

Someone asks:

“Can we go back to how it was yesterday?”

Answer:

• Maybe

• Maybe not

• Depends on which folder survived

There is no guarantee.

3. No Collaboration History

Questions like:

• Who changed this file?

• Why was this change made?

• When did this bug appear?

Had no clear answers.

Everything depended on:

• memory

• chats

• emails

Which is unreliable.

4. Sharing Code Was Slow and Risky

Code was shared using:

• pendrives

• emails

• zip files

Each transfer:

• risked data loss

• created another “version”

• added confusion

Real-World Team Problems (Beyond Pendrives)

As teams grew, problems multiplied.

Imagine:

• 5 developers

• Same codebase

• Everyone editing at the same time

Without version control:

• Conflicts were manual

• Mistakes were permanent

• Productivity dropped

At scale, this approach simply does not work.

The real problem was not tools, it was that there was no reliable system to track changes over time.

Developers needed: Histroy, safety, collaboration, accountability.

Pendrives and folders could not provide that.

This is where version control became necessary.

Version control systems solved all these problems by introducing:

• A single source of truth

• Complete change history

• Ability to go back in time

• Safe collaboration

• Clear ownership of changes

Pendrive Workflow : Edit → Copy → Share → Overwrite → Confusion

Version Control Workflow : Edit → Commit → Track → Merge → History

The difference is not convenience, it is control.

Why Version Control Is Mandatory Today

Modern development means:

• remote teams

• frequent changes

• fast releases

• large codebases

Without version control:

• mistakes are expensive

• bugs are hard to trace

• teamwork breaks down

That’s why Git (and similar systems) are not optional anymore.

Final Thoughts

The pendrive problem may sound old-school, but the idea behind it is still relevant.

Version control exists because:

• humans forget

• files get overwritten

• teams grow

• software evolves

Version control didn’t just make development easier —
it made modern development possible.