Imagine the late 90s or early 2000s.

Dr. APJ Abdul Kalam sir is working on missile software. One team is writing the warhead code, while other developers are working on different parts of the same missile - guidance system, initial launch sequence, engine control, target system, and etc.

They wrote code on their local machines, took a hard copy or saved it on a pendrive, and physically shared it with other team members. Everyone added their assigned code into that same pendrive.

Now imagine this situation:

At the end, when all the code is combined, senior developers review it and find bugs. But there’s a problem.

There is no clear tracking of:

Who wrote which part
When the code was changed
What exactly caused the bug

So to fix even a small issue, the entire codebase has to be sent back to the developer. No parallel work. No history. No easy rollback.

Just pendrive… and stress.

This chaos is what led to the birth of Version Control Systems (VCS).

Why Version Control Exists

Suppose Dr. APJ Abdul Kalam is writing the warhead code on a single pendrive.

Now here’s the problem :

That pendrive is with APJ sir, so all other developers are just waiting - they can’t write the guidance system, engine logic or target system code because only one person can use the pendrive at a time. No pendrive, no work.

APJ sir realizes this is wasting time and energy.

So he thinks: “Why not build a system where every developer can work on their own part at the same time, without blocking others - and I can still see, track, and review everyone’s code?”

That idea changes everything.

With this system:

Every developer works independently
Code changes are tracked
APJ sir can review all code in one place
Bugs can be traced back to the exact developer and change
No need to pass the entire codebase again and again

This simple but powerful idea gave birth to Version Control Systems (VCS) - a way for teams to work concurrently, safely, and without pendrive drama.

The Pendrive Analogy in Software

After writing the warhead code, Dr. APJ Abdul Kalam sir saves the folder as:

agni_missile_final

He then gives the pendrive to another developer. That developers adds the guidance system code and renames the folder to :

agni_missile_latest_final

Next, another developer works on it, adds more code, and renames it again:

agni_missile_latest_final_v2

You already know what happens next 😅

Now APJ sir is confused:

Which folder is actually final?
Which one has the latest changes?
Which code should be used?

This leads to serious problems:

Code gets overwritten
Changes are lost
Developers rewrite the same code again
There is no history of who changed what
Collaboration becomes messy and stressful

How Modern Software Solves This

Today, software is built by teams, not by passing pendrives.

Before starting, the team initializes the project with a Version Control System (VCS). Then everyone works at the same time on the same project:

One developer writes the guidance system
Another works on the target system
Someone else handles the launch code

All simultaneously, without blocking each other.

A Version Control System (VCS):

Tracks every code change
Maintains full collaboration history
Shows who changed what and when
Allows developers to roll back to a previous version if something breaks

That’s why today most developers use tools like Git, GitLab, and similar platforms.

Just clean, collaborative software development 🚀

Summary

The Pendrive Problem explains why Version Control Systems (VCS) exist in the simplest way.

In the early days, developers shared code using pendrives. Only one person could work at a time, files were renamed like final, latest_final, final_v2 and no one knew which version was correct. This caused confusion, overwritten code, lost changes and zero collaboration history.

To solve this chaos, developers needed a system where everyone could work together, at the same time, while still keeping track of every change. That idea led to Version Control Systems.

Today, teams initialize projects with VCS tools like Git and collaborate smoothly - tracking changes, fixing bugs faster and rolling back safely when something breaks.

In short: VCS replaced pendrives, confusion, and “final_final_v2” with clarity, teamwork, and control. 🚀