What is GitFlow?

GitFlow is an alternative Git branching model that involves the use of feature branches and multiple primary branches. It was first published and made popular by Vincent Driessen at nvie. Compared to trunk-based development, GitFlow has numerous, longer-lived branches and larger commits.

Important Note

GitFlow has fallen in popularity in favor of trunk-based workflows, which are now considered best practices for modern continuous software development and DevOps practices. However, understanding GitFlow is still valuable for teams working with scheduled releases or legacy systems.

Under this model, developers create a feature branch and delay merging it to the main trunk branch until the feature is complete. These long-lived feature branches require more collaboration to merge and have a higher risk of deviating from the trunk branch.

Core Branches in GitFlow

GitFlow uses two main branches to record the history of the project, plus several supporting branches for different purposes:

Main Branch

Stores the official release history. Contains production-ready code that has been thoroughly tested and approved.

Develop Branch

Serves as an integration branch for features. Contains the latest delivered development changes for the next release.

Feature Branches

Used for developing new features. Branch off from develop and merge back into develop when complete.

Release Branches

Used to prepare for new production releases. Branch off from develop and merge into both main and develop.

Hotfix Branches

Used to quickly patch production releases. Branch off from main and merge into both main and develop.

Setting Up GitFlow

The first step is to complement the default main branch with a develop branch. Here's how to set it up:

Initial Setup

# Create the develop branch

git branch develop

git push -u origin develop

# Other developers should clone and create tracking branch

git clone <repository-url>

git checkout -b develop origin/develop

This branch will contain the complete history of the project, whereas main will contain an abridged version. The develop branch serves as the integration point for all feature development.

Feature Development Workflow

Each new feature should reside in its own branch, which can be pushed to the central repository for backup and collaboration. Feature branches use develop as their parent branch.

Feature Branch Workflow

# Create a feature branch

git checkout develop

git checkout -b feature/new-feature

# Work on your feature...

git add .

git commit -m "Add new feature"

# Finish the feature

git checkout develop

git merge feature/new-feature

git branch -d feature/new-feature

Feature Branch Best Practices

Naming: Use descriptive names like feature/user-authentication
Scope: Keep features focused and manageable
Duration: Feature branches should be short-lived
Integration: Regularly merge develop into your feature branch

Release Management

Once develop has acquired enough features for a release (or a predetermined release date is approaching), you fork a release branch off of develop. This branch is used for final testing, bug fixes, and preparation for production.

Release Branch Workflow

# Create a release branch

git checkout develop

git checkout -b release/1.0.0

# Make release-specific changes (version numbers, etc.)

git commit -m "Bump version to 1.0.0"

# Finish the release

git checkout main

git merge release/1.0.0

git tag -a v1.0.0 -m "Version 1.0.0"

git checkout develop

git merge release/1.0.0

git branch -d release/1.0.0

Using a dedicated branch to prepare releases makes it possible for one team to polish the current release while another team continues working on features for the next release. It also creates well-defined phases of development.

Hotfix Management

Maintenance or "hotfix" branches are used to quickly patch production releases. Hotfix branches are based on main instead of develop, making them the only branch that should fork directly off of main.

Hotfix Workflow

# Create a hotfix branch

git checkout main

git checkout -b hotfix/critical-bug-fix

# Fix the critical bug

git commit -m "Fix critical security vulnerability"

# Finish the hotfix

git checkout main

git merge hotfix/critical-bug-fix

git tag -a v1.0.1 -m "Version 1.0.1"

git checkout develop

git merge hotfix/critical-bug-fix

git branch -d hotfix/critical-bug-fix

Hotfix Guidelines

Urgency: Only use for critical production issues
Scope: Keep changes minimal and focused
Testing: Thoroughly test before merging to main
Documentation: Document the issue and solution

Complete GitFlow Example

Here's a complete example demonstrating the GitFlow workflow:

Full GitFlow Workflow

# Initial setup

git checkout main

git checkout -b develop

# Feature development

git checkout -b feature/user-login

# ... work on feature ...

git checkout develop

git merge feature/user-login

# Release preparation

git checkout -b release/1.0.0

# ... final testing and fixes ...

git checkout main

git merge release/1.0.0

git tag v1.0.0

git checkout develop

git merge release/1.0.0

# Hotfix (if needed)

git checkout main

git checkout -b hotfix/security-patch

# ... fix critical issue ...

git checkout main

git merge hotfix/security-patch

git tag v1.0.1

git checkout develop

git merge hotfix/security-patch

When to Use GitFlow

GitFlow is most suitable for projects with specific characteristics:

✅ Good For

Projects with scheduled releases
Teams that need parallel development
Complex release management
Projects requiring hotfix capabilities
Teams with clear role separation

❌ Not Ideal For

Continuous deployment
Small teams or simple projects
Rapid iteration cycles
Modern DevOps practices
Microservices architectures

Modern Alternatives

While GitFlow was revolutionary when introduced, modern development practices have evolved. Here are some alternatives:

Trunk-Based Development

The current best practice for modern software development. Developers work directly on the main branch with short-lived feature branches that are merged quickly.

Faster integration - Changes are merged quickly
Better for CI/CD - Supports continuous deployment
Reduced complexity - Simpler branching model
Better collaboration - More frequent code sharing

For more information on modern Git workflows, check out the comprehensive guide from Atlassian:

Read Atlassian's GitFlow Guide

Conclusion

GitFlow provides a structured approach to managing complex development workflows with multiple release cycles and parallel development. While it may not be the best choice for modern continuous deployment practices, understanding GitFlow is valuable for teams working with scheduled releases or maintaining legacy systems.

The key is choosing the right workflow for your team's needs. Whether you're using GitFlow, trunk-based development, or another approach, the most important thing is that your team understands and follows the chosen workflow consistently.

Ready to implement these workflows? Use our interactive Git calculator to build the perfect commands for your branching strategy.