Pull request process in Git - Step-by-Step Execution

Process Flow - Pull request process

Developer creates feature branch

↓

Developer makes changes and commits

↓

Developer pushes branch to remote

↓

Developer opens Pull Request (PR)

↓

Team reviews PR

↓

Approve

↓

Merge PR

↓

Feature merged into main branch

This flow shows how a developer creates a branch, makes changes, pushes it, opens a pull request, gets review feedback, and finally merges the changes.

Execution Sample

Git

git checkout -b feature-branch
# make changes
git add .
git commit -m "Add new feature"
git push origin feature-branch
# open PR on GitHub
# after approval:
# merge PR on GitHub
git checkout main
git pull

This sequence shows the main git commands used during the pull request process.

Process Table

Step	Action	Command/Operation	Result/State Change
1	Create new branch	git checkout -b feature-branch	New branch 'feature-branch' created and switched to
2	Make code changes	edit files	Working directory updated with new changes
3	Stage changes	git add .	Changes staged for commit
4	Commit changes	git commit -m "Add new feature"	New commit created on 'feature-branch'
5	Push branch	git push origin feature-branch	Branch pushed to remote repository
6	Open Pull Request	Open PR on GitHub	PR created for 'feature-branch' to merge into 'main'
7	Review PR	Team reviews code	PR approved or changes requested
8	If changes requested	Developer updates branch	New commits added to 'feature-branch'
9	Merge PR	Merge PR on GitHub	Changes merged into 'main' branch
10	Update local main	git checkout main && git pull	Local 'main' updated with merged changes
11	Exit	Process complete	Feature integrated into main branch

💡 Process stops after PR is merged and local main branch is updated

Status Tracker

Variable	Start	After Step 1	After Step 4	After Step 5	After Step 9	Final
branch	main	feature-branch	feature-branch	feature-branch (remote)	feature-branch	main
commit history	main commits only	main commits + new commits on feature-branch	same	same	main + feature commits merged	main + feature commits merged
PR status	none	none	none	none	merged	merged

Key Moments - 3 Insights

Why do we create a new branch instead of working directly on main?

Creating a new branch isolates your changes so the main branch stays stable. Execution table step 1 shows branch creation before changes.

What happens if the team requests changes during review?

You update your branch with new commits (step 8), then the PR updates automatically for re-review.

Why do we pull the main branch after merging the PR?

To update your local main branch with the merged changes from remote, as shown in step 10.

Visual Quiz - 3 Questions

Look at the execution table, what is the state of the 'branch' variable after step 5?

A feature-branch deleted

B main branch active locally

C feature-branch pushed to remote

D main branch merged

💡 Hint

Check variable_tracker column 'After Step 5' for 'branch'

At which step does the pull request get merged into the main branch?

A Step 9

B Step 7

C Step 10

D Step 11

💡 Hint

Look at execution_table row with 'Merge PR' action

If the developer skips pushing the branch (step 5), what will happen when opening the PR (step 6)?

A PR opens normally with local branch

B PR cannot be created because remote branch does not exist

C PR merges automatically

D PR is created but cannot be reviewed

💡 Hint

Refer to execution_table step 5 and 6 relationship

Concept Snapshot

Pull Request Process Cheat Sheet:
- Create a feature branch: git checkout -b feature-branch
- Make changes, stage and commit: git add . && git commit -m "msg"
- Push branch to remote: git push origin feature-branch
- Open PR on remote platform (GitHub/GitLab)
- Team reviews and approves or requests changes
- Merge PR after approval
- Update local main branch: git checkout main && git pull

Full Transcript

The pull request process starts with creating a new branch to keep changes separate from the main code. Developers make changes and commit them on this branch. Then they push the branch to the remote repository. Next, they open a pull request on a platform like GitHub to ask the team to review the changes. The team reviews and either approves or requests changes. If changes are requested, the developer updates the branch with new commits. Once approved, the pull request is merged into the main branch. Finally, the developer updates their local main branch to include the merged changes. This process helps keep the main code stable and allows team collaboration.