Why Version Control Exists: The Pendrive Problem

If you are new to programming, Git and version control can feel confusing at first.
Why do we even need it? Why not just share code files normally?

To understand this, let’s go back to a very common (and painful) real-world story — the pendrive problem.

A Simple Story: Two Developers, One Project

Imagine two developers working on the same project.

• Dev 1 starts the project.

• As the project grows, the number of files also increases.

• Dev 1 needs help, so he asks Dev 2 to add a new feature.

Since there is no version control, Dev 1 does this:

1. Copies the project into a pendrive

2. Zips all the files

3. Gives the pendrive to Dev 2

Sounds simple, right?
This is where the problems begin.

What Goes Wrong Without Version Control

1. No Tracking of Code Changes

Dev 2:

• Unzips the project

• Adds a new feature

• Changes some files

Then Dev 2 returns the pendrive back to Dev 1.

Now Dev 1 has no clear idea:

• Which files were changed

• What exactly was added

• Why certain code was modified

👉 Problem: Code changes are not tracked.

2. Bug Fixes Create More Confusion

Later, Dev 2 finds a bug in his feature and fixes it.

But:

• Dev 1 still has the old version

• The fix is not in Dev 1’s code

So again:

• Zip files

• Copy to pendrive

• Share again

👉 Problem: The same process keeps repeating.

3. Only One Person Can Work at a Time

The pendrive can only be with one developer at a time.

• If Dev 2 has the pendrive, Dev 1 must wait

• They cannot work in parallel

👉 Problem: No simultaneous development.

4. Merge Conflicts Become a Nightmare

Sometimes both developers:

• Work on their own copies

• Modify the same file differently

When they try to combine changes later:

• Files conflict

• Code breaks

• No clear way to merge safely

👉 Problem: Manual merging causes errors and confusion.

5. Adding More Developers Makes It Worse

Now imagine adding Dev 3 or Dev 4.

• More pendrive sharing

• More copies

• More confusion

• More chances of losing code

👉 Problem: This system does not scale.

The Big Realization

Developers realized something important:

“Sharing code using pendrives is messy, slow, and unsafe.”

They needed:

• A way to track every change

• To know who changed what and when

• A single source of truth

• Multiple developers working at the same time

This is where version control was born.

Enter Version Control (Git)

Instead of pendrives:

• Code lives in a single shared repository

• Every change is tracked

• Each change has:

  • Developer name

  • Time and date

  • Exact file changes

Benefits:

• No lost code

• Easy bug tracking

• Safe collaboration

• History of every change

You can even track changes locally on your own machine, without sharing anything yet.

From Pendrive to Cloud

Earlier:

• Pendrive was the “source of truth”

Now:

• A central server becomes the source of truth

• All developers connect to it

• Everyone can see updates in real time

The tool that tracks code changes is called Git.
The server that hosts Git repositories can be GitHub, GitLab, Bitbucket, etc.

Final Thoughts

Version control exists not because it’s fancy, but because:

• Manual code sharing doesn’t work

• Collaboration becomes painful without tracking

• Projects grow, and chaos grows faster

Git solves the pendrive problem once and for all.

If you understand this story,
you already understand why Git exists.

#chaicode #webdevcohort2026 #git #hiteshchoudhary #piyushgarg #diliprathod