How to avoid overwriting changes in GitHub?

 
Step 1: Clone the repository and set up your local environment
 

Before making any changes, ensure you have a local copy of the repository. This prevents accidental edits on the remote directly.

• Open your terminal or command prompt.
• Navigate to the folder where you want to store the project.
• Run the clone command:

git clone https://github.com/username/repository.git
cd repository

 
Step 2: Create and switch to a new branch
 

Working on a dedicated branch isolates your work and reduces the risk of overwriting others’ changes on the main branch.

• Create a branch with a descriptive name:

git checkout -b feature/my-new-feature

 
Step 3: Make changes and commit regularly
 

Committing often helps you track progress and revert if something goes wrong. Each commit is a logical unit of change.

• Edit files in your code editor.
• Stage changes:

git add .

• Commit with a clear message:

git commit -m "Add form validation to contact page"

 
Step 4: Stash or commit your local changes before pulling
 

If you have uncommitted work, stashing saves it temporarily so you can safely pull updates without overwriting.

• To stash uncommitted changes:

git stash save "WIP: contact page validation"

• Verify your working directory is clean:

git status

 
Step 5: Synchronize your branch with remote updates
 

Always fetch and merge (or rebase) remote updates before pushing. This ensures your branch includes the latest changes.

• Fetch remote branches:

git fetch origin

• Merge updates into your branch:

git merge origin/main

• Or, if you prefer a linear history, rebase instead of merge:

git rebase origin/main

 
Step 6: Resolve merge conflicts if they occur
 

Conflicts happen when the same lines were edited in both branches. Git will mark conflicts in affected files.

• Open each conflicted file and look for conflict markers:

<<<<<<< HEAD
Your changes here
=======
Their changes here
> >>>>>> origin/main

• Edit to combine or choose one version, then save.
• Stage the resolved files:

git add path/to/conflicted-file

• Continue the merge or rebase:

git commit -m "Resolve merge conflicts"
# or, if rebasing
git rebase --continue

 
Step 7: Reapply stashed changes (if you used stash)
 

If you stashed earlier, now you can bring those changes back into your working directory.

• Apply the latest stash:

git stash pop

• Resolve any conflicts and commit as needed.

 
Step 8: Push your branch and open a Pull Request
 

Submitting your work as a pull request on GitHub lets team members review and merge safely.

• Push your branch to remote:

git push origin feature/my-new-feature

• Go to the GitHub repository in your browser.
• Click “Compare & pull request.”
• Fill in description, assign reviewers, and submit the PR.

 
Step 9: Use branch protection and review process
 

To prevent accidental overwrites on main branches, enable branch protection rules in your GitHub repository settings.

• Require pull request reviews before merging.
• Enable status checks (CI builds) to pass before merge.
• Disallow direct pushes to protected branches.

By following these steps—working on feature branches, committing frequently, stashing before pulls, syncing with fetch+merge or rebase, resolving conflicts carefully, and using pull requests with branch protection—you safeguard your work and avoid overwriting others’ changes in GitHub.