Why Version Control Exists
I decided to build an application for student enrollment. As time passed, the application started growing, and so did the codebase. I added multiple features on the frontend such as enrollment validation, API services, OTP verification, and more.
During the authentication phase, I realized that it would be better to involve a team member to handle authorization so we could move faster. Since our local LAN was not working at that time, I decided to share the project files using a pen drive.
Meanwhile, I started working on payment integration. After some time, I realized that my teammate was modifying the same files I was working on. To avoid conflicts, I paused my changes and kept my code well-commented.
Later, I received my teammate’s updated files. When I tried to review them, I found it extremely difficult to identify what exactly had changed. Still, I merged my changes manually and saved the project as "updated_app".
Soon after, my teammate discovered a bug in his code, fixed it, and shared the project again via pen drive—this time named final_1. At this point, the project had become messy, and I hesitated to continue development because of my previous experience merging changes.
Eventually, I merged both versions again and named the folder "final_updated". Now we both had the same codebase—but this only solved a temporary problem.
Problems We Still Faced
Even after syncing our code, several critical questions remained unanswered:
What if both of us change the same file again? We had no clear way to merge features without breaking the code.
How do we track changes? We couldn’t tell who changed what, when, or why.
How do we revert bugs safely? If something broke, there was no reliable way to go back to a stable version.
The Need for Version Control
To solve problems like:
Overwriting each other’s code Losing changes No history of updates No accountability
we needed a system that could track changes, manage versions, and support collaboration.
That’s where Version Control Systems (VCS) come in.
We installed a code tracker that could:
Track every change Allow multiple developers to work in parallel Merge code intelligently Maintain a complete history of the project To enable collaboration, we hosted this tracker on a central server.
Yes, we can now clearly say:
Tracker VCS: Git
Collaboration Server: GitHub
Git solved our local versioning and change-tracking problems, while GitHub enabled seamless collaboration, backup, and visibility for the entire team.
Many VCS tools and remote platforms exist today, but this article focuses on the most popular combination: Git and GitHub.
A special thanks to Linus Torvalds for creating the initial core of Git in roughly ten days, laying the foundation for one of the most powerful version control systems ever built.
