Why Version Control Exists: The Pendrive Problem in Software Development

• 1. Introduction: When Sharing Code Was a Problem

  Hitesh Sir and Piyush Sir are building the Master’ji app together.
  Hitesh Sir lives in Jaipur, and Piyush Sir lives in Chandigarh.

  In the beginning, everything feels smooth.
  Both are writing code on their own machines.

  But as the project grows, they need to share code frequently.

  To solve this, Piyush Sir suggests an idea:

  “Let’s use a pendrive or email to share the code.”

  Hitesh Sir agrees:

  “Waah yaar, badhiya idea hai!”

  At first, this seems to solve the problem.
  But distance, frequent updates, and growing code slowly make this approach painful.

  Now think about this:

  What happens when more developers join and changes increase every day?

  ---

  2. The Pendrive-Based Workflow (Before Version Control)

  Before version control systems, developers relied on manual sharing methods like:

  • Pendrives

  • Emails

  • ZIP folders

Each developer worked on their own local copy of the code.

There was:

• No central place for the latest code

• No automatic syncing

• No safety net

Files were passed from one person to another like:

    project_final  
    project_final_v2  
    project_latest  
    project_latest_final

This is what we call pendrive chaos.

---

3. Why This Workflow Feels Okay at First

For beginners, this approach feels reasonable.

When Hitesh Sir and Piyush Sir started building the Master’ji app, they thought:

“Project chhota hai.”
“Sirf hum dono hi hain.”
“Pendrive ya email kaafi hai.”

And they weren’t completely wrong.

For small projects, few developers, and simple changes this works for some time.

It doesn’t break immediately.
It breaks silently.

---

4. When Two People Edit the Same File

Now imagine this situation:

• Hitesh Sir edits app.js

• Piyush Sir edits the same app.js

• Both think their changes are correct

When files are shared:

• One version replaces the other

• One person’s work disappears

---

5. Core Problems That Start Appearing

Slowly, real problems begin.

Overwritten code
Hitesh Sir sends his changes.
Piyush Sir sends his version later.
Hitesh Sir’s work is gone.

Lost changes
After a few days, both wonder:

“Kal kya change hua tha?”

No idea who changed what
A bug appears, but no one knows who wrote that code.

No history to go back to
Once overwritten, the old code is lost forever.

---

6. How Things Get Worse Over Time

• As days pass:

  • Changes keep piling up

  • Old versions disappear

  • Bugs appear with no clear source

“We don’t even know when this bug was introduced.”

7. Why This Becomes a Nightmare in Team Projects

As teams grow, more people edit the same files.
Confusion increases. Changes clash.

Without tracking, debugging becomes guessing.
Frustration grows. Productivity drops.

At this point,
sharing code feels harder than writing it.

8.Final Thoughts

This is where Hitesh sir and Piyush sir realized something important.

For example when Hitesh sir and Piyush sir building the Master’ji app, sharing the code using Pendrives was no longer enough.

It didn’t protect the code history.

It didn’t support the real-time collaboration.

To build the software with growing teams and constant changes, developers needed a better and safer way to track the share code.

And that’s need is what led to birth of the Version Control Systems.