Git Notes
HubBenefits of Git and GitHub - Why They MatterGit vs GitHubVersion Control SystemWhat Is GitWhat Is GitHubConfigure Git - User Identity and SettingsCreate GitHub Account - Sign Up GuideFirst Git Repository - Getting StartedInstall Git on Linux - Complete Setup GuideInstall Git on macOS - Installation GuideInstall Git on Windows - Step-by-Step GuideGit Add - Stage ChangesGit Clone - Copy Remote Repositories LocallyGit Commit - Save ChangesGit Diff - Compare Changes in Your RepositoryGit Ignore - Exclude Files from Version ControlGit Init - Initialize RepositoryGit Log - View Commit HistoryGit Status - Check Repository StateGit Fetch - Download Remote Changes Without MergingGit Pull - Fetch and Merge Remote ChangesGit Push - Upload Local Commits to Remote RepositoryGit Remote - Manage Remote Repository ConnectionsLocal Repository - Understanding Your Git Working EnvironmentRemote Repository - Collaborate Through Shared RepositoriesSync Local and Remote - Keep Repositories in HarmonyAmend Commit - Fix Last CommitDelete Branch - Clean Up BranchesGit Reset - Move HEAD and Undo CommitsGit Restore - Discard ChangesGit Revert - Safely Undo ChangesRecover Lost Commits - Reflog GuideFork RepositoryGitHub PagesGitHub Profile SetupGitHub RepositoriesGitHub Stars and WatchersRepository SettingsCode ReviewsGit CloneGit FetchGit PullGit PushGitHub IssuesLabels and MilestonesOpen Source ContributionsGitHub Project BoardsPull Requests - Propose and Review Code ChangesTeam Collaboration with Git and GitHubAutomated Testing with GitHub ActionsCI/CD with GitHub ActionsDeployment Automation with GitHub ActionsIntroduction to GitHub ActionsGitHub Actions RunnersGitHub Actions WorkflowsEnterprise Git Workflows - Scale Git for Large OrganizationsFeature Branch Workflow - Isolate Development WorkGitFlow Workflow - Structured Release ManagementMonorepo Workflow - Manage Multiple Projects in One RepositoryTrunk-Based Development - Ship Code Fast and SafelyDeployment WorkflowsGitHub Pages DeploymentNetlify Deployment from GitHubRender Deployment from GitHubVercel Deployment from GitHubBranch Protection Rules - Secure Your Git BranchesPersonal Access Tokens - Authenticate with GitHubRepository Security Best PracticesSecret Scanning - Detect Leaked Credentials in CodeSigned Commits - Verify Commit Authenticity with GPGSSH Keys - Secure Git Authentication Without PasswordsGit Bisect - Find Bugs with Binary SearchGit Cherry-Pick - Apply Specific Commits to Any BranchGit Hooks - Automate Workflows with Git EventsGit Internals - Understanding How Git Works Under the HoodGit Stash - Temporarily Save Uncommitted ChangesGit Submodules - Manage External Dependencies as Git ReposGit Tag - Mark Important Points in HistoryGit Worktrees - Work on Multiple Branches SimultaneouslyCollaborative Web App ProjectComplete Team Workflow ProjectGitHub Actions Project - Build a CI/CD PipelineOpen Source Project Contribution - Guided ExercisePortfolio Project with Git - Showcase Your SkillsGit Command CheatsheetGit Interview Questions - Comprehensive Preparation GuideGitHub Interview QuestionsScenario-Based Git Interview QuestionsGit Troubleshooting GuideGit Best Practices - Professional Development HabitsCommon Git Errors and Fixes - Quick SolutionsGit Command Reference - Complete Command GuideLearning Resources - Continue Your Git & GitHub EducationBranch Strategies - Choosing the Right Git Branching ModelCreate Branch in Git - Start New Development LinesFast-Forward Merge in Git - Clean Linear HistoryGit BranchGit CheckoutGit MergeGit RebaseMerge Branches in Git - Combine Development WorkMerge Conflicts - Resolve Git Conflicts Like a ProSwitch Branch in Git - Navigate Between Branches
Explore popular Git branching strategies including GitFlow, GitHub Flow, and trunk-based development. Learn when to use each strategy for your team and project.
A branching strategy defines how your team creates, names, and merges branches. The right strategy depends on your team size, release frequency, and project complexity.
Why Branching Strategies Matter
Without a clear branching strategy:
- Developers step on each other's work
- Releases become unpredictable
- Hotfixes are difficult to deploy
- Code review processes break down
Popular Branching Strategies
GitHub Flow (Simple)
Best for: Continuous deployment, small teams, web applications
Example
main ─────●─────●─────●─────●─────●─────●─────
\ / \ /
feature-1 ●───●───●──────┘ \ /
●───●
feature-2
Rules:
mainis always deployable- Create feature branches from
main - Open a Pull Request for discussion
- Merge to
mainafter review - Deploy immediately after merge
bash example
# GitHub Flow in practice
git checkout main
git pull origin main
git checkout -b feature/user-auth
# Work on feature...
git add .
git commit -m "Add user authentication"
git push origin feature/user-auth
# Open PR on GitHub, get review, mergeGitFlow (Structured)
Best for: Scheduled releases, larger teams, versioned software
Example
main ─────●───────────────────●───────────────●
\ / \
develop ─────●───●───●───●───●───●───●───●───●───●
\ / \ / \
feature-1 ●───●──┘ \ / \
●───●──┘ release/1.1
release/1.0
Branches:
main— production-ready codedevelop— integration branchfeature/*— new featuresrelease/*— release preparationhotfix/*— urgent production fixes
bash example
# Start a new feature
git checkout develop
git checkout -b feature/shopping-cart
# Finish feature
git checkout develop
git merge feature/shopping-cart
# Create release
git checkout -b release/1.0 develop
# ... testing and bug fixes ...
git checkout main
git merge release/1.0
git tag v1.0
# Hotfix
git checkout -b hotfix/critical-bug main
# ... fix ...
git checkout main
git merge hotfix/critical-bug
git checkout develop
git merge hotfix/critical-bugTrunk-Based Development
Best for: Experienced teams, CI/CD pipelines, microservices
Example
main (trunk) ───●───●───●───●───●───●───●───●───●───
\ / \ / \ /
●─┘ ●─┘ ●─┘
(short-lived feature branches, < 1 day)
Rules:
- Everyone commits to
main(or very short-lived branches) - Feature flags hide incomplete features
- Branches live at most 1-2 days
- Continuous integration runs on every push
bash example
# Trunk-based: short-lived branches
git checkout main
git pull
git checkout -b fix/button-color
# Quick fix (same day)
git add .
git commit -m "Fix button color on mobile"
git push origin fix/button-color
# Merge PR immediately after CI passesStrategy Comparison
| Factor | GitHub Flow | GitFlow | Trunk-Based |
|---|---|---|---|
| Complexity | Low | High | Low |
| Release type | Continuous | Scheduled | Continuous |
| Team size | Small-Medium | Medium-Large | Any |
| Branch lifetime | Days | Days-Weeks | Hours-1 Day |
| Parallel releases | No | Yes | No |
| Hotfix process | Simple | Defined | Simple |
| CI/CD requirement | Recommended | Optional | Required |
Branch Naming Conventions
Consistent naming helps everyone understand the purpose of each branch:
bash example
# Feature branches
feature/user-authentication
feature/JIRA-123-payment-gateway
feat/add-search-bar
# Bug fix branches
bugfix/login-redirect
fix/null-pointer-exception
# Hotfix branches
hotfix/security-patch
hotfix/v2.1.1
# Release branches
release/1.0.0
release/2024-Q1
# Experimental branches
experiment/new-ui-framework
spike/performance-testingNaming Best Practices
bash example
# DO: Use lowercase with hyphens
feature/add-user-profile
# DO: Include ticket numbers
feature/PROJ-456-email-notifications
# DON'T: Use spaces or special characters
feature/Add User Profile # Bad
feature/add_user_profile # Acceptable but inconsistent
# DON'T: Use vague names
feature/updates # Bad - what updates?
feature/fix # Bad - fix what?Choosing the Right Strategy
Ask these questions:
- How often do you release? Daily → GitHub Flow or Trunk-Based; Weekly/Monthly → GitFlow
- How many developers? 1-5 → GitHub Flow; 5+ → GitFlow or Trunk-Based
- Do you support multiple versions? Yes → GitFlow; No → GitHub Flow
- Is CI/CD mature? Yes → Trunk-Based; Growing → GitHub Flow
- Are developers experienced with Git? Mixed → GitHub Flow; Advanced → Trunk-Based
Interview Questions
- What branching strategy would you recommend for a startup with 3 developers deploying daily?
GitHub Flow — it is simple, supports continuous deployment, and does not add unnecessary process overhead for a small team.
- When would you choose GitFlow over GitHub Flow?
When you need to support multiple release versions simultaneously, have scheduled releases, or work with a larger team that needs clear separation between development and production code.
- What are the key principles of trunk-based development?
Small frequent commits to main, very short-lived branches (hours not days), feature flags for incomplete work, strong CI/CD pipeline, and automated testing.
- How do you handle hotfixes in different branching strategies?
In GitHub Flow, branch from main and merge back. In GitFlow, create a hotfix branch from main, fix, merge to both main and develop. In trunk-based, commit directly to main with an expedited review.
- What is the role of feature flags in branching strategies?
Feature flags decouple deployment from release. Code can be merged to main without being visible to users, enabling trunk-based development and reducing long-lived branches.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Branch Strategies - Choosing the Right Git Branching Model.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Git & GitHub topic.
Search Terms
git-github, git & github, git, github, branching, and, merging, branch
Related Git & GitHub Topics
Continue learning this concept
Branching And MergingCreate Branch in Git - Start New Development LinesLearn how to create branches in Git for feature development, bug fixes, and experimentation. Understand branch creation from different starting points.Branching And MergingGit BranchBranching is one of the most powerful features in Git, and understanding how to work with branches effectively is what separates a beginner from a...Branching And MergingSwitch Branch in Git - Navigate Between BranchesLearn how to switch between branches using git checkout and git switch. Understand branch switching behavior, stashing changes, and handling uncommitted work.Branching And MergingFast-Forward Merge in Git - Clean Linear HistoryUnderstand fast-forward merges in Git, when they happen, how they differ from three-way merges, and how to control merge behavior with --no-ff and --ff-only flags.Branching And MergingGit CheckoutThe git checkout command is one of the most versatile commands in Git, which is both its strength and its source of confusion for newcomers. Historically,...Branching And MergingGit MergeMerging is the process of combining the work from two different branches into one. It is how features developed in isolation come together to form a...