Git - Workflow

Workflow of Git

What is a Git Workflow?

A Git workflow is a set of guidelines and practices that define how developers use Git to collaborate on a project. A well-defined workflow ensures that contributors know how to manage branches, commit changes, review code, and deploy releases. It also helps maintain code stability and supports scalability in teams of all sizes.

Why Workflows Matter

• Promotes collaboration among team members
• Helps avoid merge conflicts
• Supports continuous integration and delivery (CI/CD)
• Allows safe experimentation with new features
• Facilitates clear communication and code reviews

Basic Building Blocks of a Workflow

Working Directory

This is where your project files are located. Any modifications you make to files are first done here.

Staging Area (Index)

Before committing, you need to stage your changes. This allows you to prepare specific changes for the next commit.

git add filename.txt

Repository (Local)

This contains your full Git history and metadata. Once you commit, the changes are saved in your local repository.

git commit -m "Describe your change"

Remote Repository

This is usually hosted on a platform like GitHub, GitLab, or Bitbucket. You sync your local repository with the remote to collaborate with others.

git push origin main
git pull origin main

Common Git Workflows

1. Centralized Workflow

The centralized workflow uses a single central repository and is similar to the traditional version control systems like Subversion (SVN).

Key Characteristics

• All team members push and pull from a single central repository
• Typically one main branch (e.g., main or master)
• Suitable for small teams or simple projects

Steps

# Clone the central repository
git clone https://github.com/example/repo.git

# Make changes
git add .
git commit -m "Update something"

# Push changes to the central repo
git push origin main

2. Feature Branch Workflow

This workflow encourages the use of isolated branches for every new feature or bug fix. The main branch remains stable while work is done in parallel.

Key Characteristics

• Encourages creating a new branch for each feature
• Makes code review and testing easier
• Protects the stability of the main branch

Steps

# Create a feature branch
git checkout -b feature/add-login

# Work on the feature
git add .
git commit -m "Add login functionality"

# Push the feature branch
git push origin feature/add-login

# Create a pull request and merge after approval

3. Git Flow Workflow

Git Flow is a more structured workflow that defines strict roles for different branches. It works well for large projects with scheduled release cycles.

Branch Types

• main: Holds production-ready code
• develop: Integration branch for features
• feature: New features branch out from develop
• release: Prepares code for production release
• hotfix: Urgent fixes to production code

Steps

# Start a new feature
git checkout develop
git checkout -b feature/awesome-feature

# Finish the feature
git checkout develop
git merge feature/awesome-feature

# Start a release
git checkout -b release/v1.0.0

# Finish the release
git checkout main
git merge release/v1.0.0
git tag -a v1.0.0 -m "Release version 1.0.0"

# Merge back into develop
git checkout develop
git merge release/v1.0.0

4. Forking Workflow

Used in open-source projects, the forking workflow allows contributors to make changes in their own copy of the repository and submit a pull request.

Steps

# Fork the repository on GitHub

# Clone your forked copy
git clone https://github.com/your-username/repo.git

# Add the original repo as upstream
git remote add upstream https://github.com/original/repo.git

# Create a new branch
git checkout -b fix/bug-issue

# Push your changes
git push origin fix/bug-issue

# Submit a pull request to the original repository

5. Trunk-Based Development

All developers work in a single branch (typically main) and integrate changes frequently. It supports continuous integration and fast iterations.

Best Practices

• Use feature flags to manage incomplete features
• Commit small and frequently
• Use CI/CD pipelines for automated testing

Typical Git Workflow for Teams

Step 1: Clone the Repository

git clone https://github.com/team/repo.git

Step 2: Create a New Branch

git checkout -b feature/my-feature

Step 3: Work Locally

# Make code changes
git add .
git commit -m "Implement my feature"

Step 4: Sync with Remote

# Pull latest changes
git pull origin main

# Push your branch
git push origin feature/my-feature

Step 5: Open a Pull Request

Use the GitHub/GitLab UI to open a pull request. Collaborators review and approve before merging.

Step 6: Merge and Deploy

# Merge the branch after approval
git checkout main
git merge feature/my-feature

# Delete the branch if no longer needed
git branch -d feature/my-feature

Collaboration Best Practices

• Always pull before you push to avoid conflicts
• Use clear, descriptive commit messages
• Keep commits small and focused
• Test code before pushing
• Use pull requests for code review and discussion

Conflict Resolution

Detecting Conflicts

# Happens during merge or pull
Auto-merging file.txt
CONFLICT (content): Merge conflict in file.txt

Resolving Conflicts

Open the file, fix the conflict manually, and then stage and commit.

# After resolving
git add file.txt
git commit -m "Resolved merge conflict in file.txt"

Continuous Integration with Workflows

Most modern teams integrate Git workflows with CI tools like GitHub Actions, Jenkins, or GitLab CI. These tools automatically test, build, and sometimes deploy code after every push or merge.

Example GitHub Actions Workflow

name: Node.js CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Install dependencies
        run: npm install
      - name: Run tests
        run: npm test

Understanding Git workflows is essential for modern software development. Whether you're a solo developer managing side projects or part of a large organization maintaining enterprise applications, choosing the right Git workflow can dramatically impact your productivity, code quality, and team coordination.

We covered the fundamental components of a Git workflow, common types of workflows including centralized, feature-based, Git Flow, forking, and trunk-based development, and practical steps for collaborating effectively. By mastering Git workflows and following best practices, developers can contribute more efficiently, handle changes safely, and maintain high-quality software projects.