Git flow that's simple, easy to manage, and generally applicable
Tags: git, development, softwaredevelopment, webdev
Published: 2024-07-16 17:05:01

This Git flow ensures a structured and organized development process, making it easier to manage changes, track progress, and maintain the stability of the main codebase while incorporating a dedicated branch for QA testing.

## Branching Strategy

### Main Branches
- **`main`**: This branch contains the production-ready code. Every commit to `main` should be a release.
- **`develop`**: This branch contains the latest development changes. It is the integration branch for feature branches.

### Supporting Branches
- **`feature/*`**: These branches are used to develop new features. They branch off from `develop` and are merged back into `develop` once the feature is complete.
- **`bugfix/*`**: These branches are used to fix bugs found in the `develop` branch. They branch off from `develop` and are merged back into `develop` once the bug is fixed.
- **`release/*`**: These branches support the preparation of a new production release. They allow for minor bug fixes and preparing meta-data for a release (version number, build date, etc.). They branch off from `develop` and are merged into both `develop` and `main`.
- **`hotfix/*`**: These branches are for critical fixes that need to be applied directly to the `main` branch. They branch off from `main` and are merged back into both `main` and `develop`.

## Workflow

### Feature Development
1. Create a new feature branch from `develop`:
    ```bash
    git checkout develop
    git pull origin develop
    git checkout -b feature/your-feature-name
    ```
2. Develop your feature.
3. Once the feature is complete and tested locally, push it to the remote repository:
    ```bash
    git push origin feature/your-feature-name
    ```
4. Create a merge request (MR) from `feature/your-feature-name` to `develop`.

### Bug Fixing
1. Create a new bugfix branch from `develop`:
    ```bash
    git checkout develop
    git pull origin develop
    git checkout -b bugfix/your-bugfix-name
    ```
2. Fix the bug.
3. Once the bug is fixed and tested locally, push it to the remote repository:
    ```bash
    git push origin bugfix/your-bugfix-name
    ```
4. Create a merge request (MR) from `bugfix/your-bugfix-name` to `develop`.

### Preparing a Release
1. When all the features for the next release are merged into `develop`, create a new release branch:
    ```bash
    git checkout develop
    git pull origin develop
    git checkout -b release/0.0.1
    ```
2. Perform final testing and bug fixing on the `release/0.0.1` branch.
3. Once the release is ready, merge it into `main`:
    ```bash
    git checkout main
    git pull origin main
    git merge release/0.0.1
    git push origin main
    ```
4. Also, merge it back into `develop` to keep it updated:
    ```bash
    git checkout develop
    git pull origin develop
    git merge release/0.0.1
    git push origin develop
    ```
5. Delete the release branch:
    ```bash
    git branch -d release/0.0.1
    git push origin --delete release/0.0.1
    ```

### Hotfixes
1. Create a hotfix branch from `main`:
    ```bash
    git checkout main
    git pull origin main
    git checkout -b hotfix/your-hotfix-name
    ```
2. Fix the issue.
3. Once the hotfix is complete, merge it into `main`:
    ```bash
    git checkout main
    git pull origin main
    git merge hotfix/your-hotfix-name
    git push origin main
    ```
4. Also, merge it into `develop` to keep it updated:
    ```bash
    git checkout develop
    git pull origin develop
    git merge hotfix/your-hotfix-name
    git push origin develop
    ```
5. Delete the hotfix branch:
    ```bash
    git branch -d hotfix/your-hotfix-name
    git push origin --delete hotfix/your-hotfix-name
    ```

## Merging Rules
- **Feature/Bugfix to Develop**: A feature or bugfix branch must pass code review and be tested locally before being merged into `develop`.
- **Release to Main**: The release branch must pass final QA testing before being merged into `main`.
- **Hotfix to Main and Develop**: Hotfix branches should be used for critical issues in the production environment and must be merged into both `main` and `develop` after fixing.


## Conclusion

This Git flow provides a clear and straightforward process for managing development, testing, and releases. By using dedicated branches for features, bug fixes, QA testing, and hotfixes, it ensures code quality and stability, making it easier to track progress and maintain the main codebase.