Do you know how the conceptual difference and usability of tag and branch in git?

Short answer:

A branch in Git is a movable pointer to a specific commit that allows independent development and merging with the main codebase, while a tag is a static marker for a specific version in the Git history that provides a way to easily reference a stable code release.

What is a Branch in Git

A Git branch is a way to separate work in progress from the main codebase. It allows multiple developers to work on different features or bug fixes in parallel, without affecting the main codebase. Branches are lightweight and can be easily created, merged, and deleted, making them ideal for daily development work.

Git branches
Git branches

In a typical software development workflow, each developer will create a branch for their feature or bug fix. The branch is where they do their work and make commits to record their changes. Once the work is complete, the branch can be reviewed and tested by other team members before being merged back into the main codebase. This allows for easy collaboration and makes it possible to work on multiple tasks simultaneously.

Using branches in this way can help keep the main codebase stable, reduce conflicts, and make it easier to revert changes if necessary. In general, it’s a good practice to create a new branch for each separate piece of work, and to merge branches back into the main codebase as soon as they are finished.

To use branches in Git, you can create a new branch with the git branch command and switch to it with git checkout. You can then make changes and commit them to your branch. When you’re ready to merge your changes back into the main codebase, you can use the git merge command.

What is a Tag in Git

A Git tag is a way to mark a specific version of your codebase, providing a way to easily reference a stable release or specific point in the Git history. Unlike branches, tags are immutable, meaning they cannot be changed after they are created. This makes them useful for marking releases, as it provides a way to easily revert to a known good state if necessary.

Git Tags
Git Tags

In a software development workflow, tags are typically used to mark specific releases or milestones. For example, you might tag a version of the code when it’s ready to be shipped to production. The tag provides a permanent reference to that version of the code, making it easy to revert to that version if necessary.

Using tags in this way can help keep track of the different releases of your codebase, making it easier to roll back to a previous version if necessary. In general, it’s a good practice to tag each release, so you have a permanent record of the specific version that was shipped to production.

To use tags in Git, you can create a new tag with the git tag command. You can then push the tag to your remote repository, so that other team members have access to it. When you want to revert to a specific tag, you can use the git checkout command to switch to the tagged version.

Git Branch vs Tag

So, shortly:

  • Tag is just a label, usually within a specific branch that defines a situation at a given time.
  • Branch, is a ramification in parallel to another path or “group of code” that will potentially be incorporated into the main development, or rather specifying, the main branch.

The tag usually marks a release, a version or other milestone of the similar project. So the tag is just a label for a specific commit while a branch is a path, a development ramification.

In Git there is no “cost” in defining a tag, they are a symbolic marking and do not take up space in the repository. You do not change what is in the tag. It will be used eventually, when there is some important development event that needs this marking to return to it other times.Usually this event is a release.

Development work is always done on Branches through the commits.

It is in branches that is made the merge, from the state / previous changes with what was developed.

A branch is being added from development evolutions.

A good practice is the creation of a new branch whenever possible, when a new development line will be started.

The following image visually shows the history of a Git repository with its tags and branches:


You can also define a _ ** branch ** _ as a branch of your main “tree” of development, usually created to work on developing corrections or new implementations.

Upon completion of work for that context, we can make a MERGE for the main branch of your project.


The branch is responsible for receiving the modifications during the context of development, with each new functionality it is advisable to generate new branches. When the project is already mature and stable is generated a new release that will be stored or marked by a repository tag.