DEV Community

Cover image for Best Practices for Git and Version Control
Aneeqa Khan
Aneeqa Khan

Posted on

Best Practices for Git and Version Control

#git #programming #beginners #productivity

Version control is a fundamental part of software development, helping teams collaborate efficiently, track changes, and maintain a clean, stable codebase.

This article will cover the best practices for version control in your next project.

1. Initialize and Configure Git Properly

If your project isn’t already under version control, initialize Git in your project directory:

git init
Enter fullscreen mode Exit fullscreen mode

Then, create a .gitignore file to prevent unnecessary files from being tracked. Here’s an example .gitignore for React Native:

# Node modules  
node_modules/  

# Build files  
android/app/build/  
ios/Pods/  

# Logs & cache  
*.log  
.npm/  
.expo/  

# Environment files  
.env
Enter fullscreen mode Exit fullscreen mode

This keeps the repository clean and prevents unnecessary clutter in the version history.

2. Follow a Branching Strategy

Using a structured branching model prevents conflicts and keeps development organized. A feature branch workflow is recommended:

  • main (or master) branch – Stable production-ready code.
  • develop branch – The latest changes are being tested before release.
  • Feature branches — Used for new features, named accordingly (e.g., feature/login-screen).
  • Bugfix/hotfix branches — Used to fix urgent issues (e.g., bugfix/crash-fix).

To create and switch to a feature branch:

git checkout -b feature/new-feature
Enter fullscreen mode Exit fullscreen mode

After making changes, push the branch:

git push origin feature/new-feature
Enter fullscreen mode Exit fullscreen mode

Once the feature is complete, merge it into develop:

git checkout develop  
git merge feature/new-feature  
git push origin develop
Enter fullscreen mode Exit fullscreen mode

3. Write Meaningful Commit Messages

Avoid generic messages like Updated code. Instead, write clear and descriptive commit messages:

git commit -m "Added user authentication flow with Firebase"
Enter fullscreen mode Exit fullscreen mode

A good commit message should:

✔️ Describe what changed
✔️ Explain why it was changed (if necessary)
✔️ Use the imperative tense (e.g., “Fix bug in login screen”)

4. Commit Small, Logical Changes

Committing frequently and keeping changes small makes it easier to track progress and revert issues. Instead of one large commit, break it down:

✅ Good:

git commit -m "Implemented UI for sign-up screen"
git commit -m "Connected sign-up screen to API"
git commit -m "Fixed validation errors on sign-up form"
Enter fullscreen mode Exit fullscreen mode

❌ Bad:

git commit -m "Updated app"
Enter fullscreen mode Exit fullscreen mode

5. Pull Before You Push

Before pushing your changes, always pull the latest changes from the remote repository to avoid merge conflicts:

git pull origin develop
Enter fullscreen mode Exit fullscreen mode

If conflicts occur, Git will highlight them, and you must resolve them manually before committing to the final version.

6. Use Git Tags for Releases

Tagging helps track stable releases and simplifies rollbacks. You can tag a release like this:

git tag -a v1.0.0 -m "First production release"
git push origin v1.0.0
Enter fullscreen mode Exit fullscreen mode

Later, you can check out a specific version if needed:

git checkout tags/v1.0.0
Enter fullscreen mode Exit fullscreen mode

7. Use Pull Requests and Code Reviews

Instead of merging directly into main or develop, use pull requests (PRs) on platforms like GitHub or GitLab. This allows for:

✔️ Code review before merging
✔️ Automated testing before deployment
✔️ A history of who changed what and why

8. Keep Your Repository Clean

Large repositories slow down performance. Regularly remove unnecessary dependencies and logs. If sensitive data like API keys get committed accidentally, remove them securely:

git filter-branch --force --index-filter \
'git rm --cached --ignore-unmatch path/to/file' \
--prune-empty --tag-name-filter cat -- --all
Enter fullscreen mode Exit fullscreen mode

Then, force push to overwrite the remote repository:

git push origin --force --all
Enter fullscreen mode Exit fullscreen mode

9. Automate with Git Hooks and CI/CD

Automating checks before committing helps maintain quality. Use Git hooks to run linting, tests, or format code before committing:

Create a pre-commit hook in .git/hooks/pre-commit:

#!/bin/sh
npm run lint
npm test
Enter fullscreen mode Exit fullscreen mode

Also, integrate CI/CD pipelines like GitHub Actions or GitLab CI/CD to run tests automatically on every push:

name: React Native CI
on: push
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Install dependencies
        run: npm install
      - name: Run tests
        run: npm test
Enter fullscreen mode Exit fullscreen mode

10. Backup and Maintain a Remote Repository

Always push your changes to a remote repository like GitHub, GitLab, or Bitbucket. If you are working solo, having a remote backup is still essential:

git push origin develop
Enter fullscreen mode Exit fullscreen mode

Use GitHub Issues or Project Boards to track tasks and organize workflow efficiently.

Conclusion

Following these best practices ensures a smooth version control process for your project. By using structured branching, meaningful commits, automation, and regular code reviews, you can maintain a scalable, conflict-free codebase.

Thank you for reading! Feel free to connect with me on LinkedIn or GitHub.

Top comments (0)