Course Curriculum
MODULE 01 Version Control & Git Fundamentals
WHY THIS MODULE

Git is on every job description for developers and testers. Whether you are uploading automation test scripts, collaborating on a framework, or contributing to any project, Git is the universal tool. Starting without understanding why version control exists and how Git is architectured means you will always be copying commands without knowing what they actually do. This foundation makes everything else click.

Key Topics Covered
Version Control Concepts Centralised vs Distributed VCS CVS / SVN vs Git Git Architecture Working Directory / Staging / Repository Local vs Remote GitHub vs GitLab vs Bitbucket Git in Automation Testing
What You Will Be Able to Do
  • Explain what version control is and why every software team on the planet uses it
  • Describe how Git's distributed model differs from older centralised tools like SVN
  • Understand Git's three-zone model: working files, staging preview, and permanent history
  • Explain where Git fits in the automation testing and CI/CD pipeline
  • Compare GitHub, GitLab, and Bitbucket and choose the right platform for a project
MODULE 02 Git Installation & Configuration
WHY THIS MODULE

A mis-configured Git setup causes frustrating issues later — anonymous commits with no name, authentication failures, or commands that silently fail. Getting your identity and connection method right from the start means all your commits are properly attributed to you, your pushes to GitHub always work, and you never have to troubleshoot basic setup issues on a real project deadline.

Key Topics Covered
Git Installation (Windows) Git Bash git --version git config --global user.name git config --global user.email git config --list .git Folder Structure GitHub Account Setup HTTPS vs SSH
What You Will Be Able to Do
  • Install Git on Windows and confirm it is running correctly
  • Set your global identity (name + email) so every commit is properly attributed to you
  • Inspect and understand the .git folder that Git creates inside every repository
  • Create and configure a GitHub account ready for repository hosting
  • Choose between HTTPS (web address) and SSH (key-based) access to GitHub
MODULE 03 Core Git Commands
WHY THIS MODULE

These five commands — init, add, commit, log, diff — make up 80% of your daily Git usage. Every automation engineer, every developer, every tester runs these multiple times a day. Without a solid grasp of the add-commit cycle, you will make mistakes like accidentally committing everything at once or writing useless commit messages that make it impossible to trace when a bug was introduced. These are the non-negotiable fundamentals.

Key Topics Covered
git init git status git add . / git add <file> git commit -m git log git log --oneline git diff git diff --staged Commit Best Practices File Lifecycle: Untracked → Staged → Committed
What You Will Be Able to Do
  • Turn any folder into a Git repository instantly using git init
  • Stage specific files or all changes using git add, and understand why staging exists
  • Save a permanent snapshot with a meaningful message using git commit -m
  • Browse the full project history using git log and git log --oneline
  • See exactly what changed in any file before and after your edits using git diff
  • Understand why every file goes through three states: untracked → staged → committed
MODULE 04 Working with Remote Repositories
WHY THIS MODULE

Git on your laptop is personal version control. Git with GitHub is team collaboration. Every real-world project — every automation framework, every company codebase — lives on a remote platform like GitHub. You need to know how to clone projects, push your changes, and pull your teammates' updates. This is the skill that connects your local work to the team's shared codebase.

Key Topics Covered
git clone <url> git remote add origin git remote -v git push origin main git pull git fetch origin / upstream Tracking Branches .gitignore README.md
What You Will Be Able to Do
  • Copy any GitHub project to your computer using git clone
  • Connect a local repository to GitHub as its remote origin
  • Upload your committed changes to GitHub using git push
  • Download and apply teammates' latest changes using git pull
  • Understand the difference: git fetch downloads without applying, git pull downloads and applies
  • Create .gitignore to keep secrets, IDE settings, and build outputs off GitHub
MODULE 05 SSH Authentication
WHY THIS MODULE

Without SSH, every push and pull to GitHub requires you to enter your username and password — which GitHub no longer even accepts. SSH authentication is the industry-standard secure method: your computer has a digital key, GitHub recognises it, and you connect without typing a password ever again. Every developer sets this up exactly once and benefits from it every single day for the rest of their career.

Key Topics Covered
SSH vs HTTPS ssh-keygen -t ed25519 Public Key / Private Key Adding SSH Key to GitHub ssh -T git@github.com SSH Config File SSH Troubleshooting Personal Access Token (PAT)
What You Will Be Able to Do
  • Generate an SSH key pair — a private key your computer keeps and a public key you share with GitHub
  • Add the public key to GitHub so it permanently recognises your machine
  • Test the connection with a single command and confirm it works
  • Configure SSH to handle multiple GitHub accounts from one machine
  • Resolve the most common SSH errors that appear during first-time setup
  • Understand PATs as a fallback authentication method for specific use cases
MODULE 06 Branching — Create, Switch & Manage
WHY THIS MODULE

Branching is what makes Git truly powerful for teams. Without branches, everyone would be editing the same files at the same time — chaos. With branches, each person gets their own safe workspace. The main project stays stable while features, bug fixes, and experiments all happen in isolation. Every professional team runs on branches — if you do not know how to use them, you cannot work in any real team environment.

Key Topics Covered
git branch git branch <name> git checkout -b <name> git switch git branch -d / -D git branch -r HEAD pointer Feature Branch Workflow Branch Naming Conventions Branch Flow Diagram
What You Will Be Able to Do
  • Create a branch and start working in isolation without touching the main project
  • Switch between branches instantly and understand what HEAD is pointing to at any time
  • List all branches — on your computer and on GitHub — in a single command
  • Name branches clearly using professional conventions: feature/, bugfix/, hotfix/, release/
  • Delete branches after they have been merged to keep the repository clean
  • Draw and explain a branching workflow diagram as you would in an interview
MODULE 07 Merging & Conflict Resolution
WHY THIS MODULE

Merge conflicts are one of the most anxiety-inducing moments for new Git users — but they are completely normal and happen in every active team. The difference between a junior and a senior engineer is not avoiding conflicts, it is resolving them calmly and correctly. This module removes all the fear: once you understand what Git is trying to tell you, resolving conflicts becomes a five-minute routine task.

Key Topics Covered
git merge <branch> Fast-Forward Merge 3-Way Merge Merge Conflicts Conflict Markers (<<< === >>>) Manual Conflict Resolution git merge --abort Conflict Prevention Strategies Merge vs Rebase
What You Will Be Able to Do
  • Merge a completed feature branch back into main successfully
  • Recognise when Git merges automatically and when it needs human input
  • Read and understand the conflict markers (<<<, ===, >>>) Git inserts in conflicted files
  • Manually edit the file to keep the correct version and complete the merge
  • Abort a merge that has gone wrong and return to the pre-merge state
  • Adopt working habits (frequent pulls, small commits, dedicated branches) that prevent most conflicts
MODULE 08 Stash, Reset & Undoing Changes
WHY THIS MODULE

Mistakes happen — a wrong commit, a file that should never have been staged, an experiment that broke everything. Git's undo tools are designed for exactly these moments. But not all undo commands are equal: some are safe to use on shared code, and some will cause chaos if used on a branch your teammates already have. Understanding the difference protects you and your team from the most common Git disasters.

Key Topics Covered
git stash git stash pop / list / drop git reset --soft HEAD~1 git reset --mixed HEAD~1 git reset --hard HEAD~1 git revert <commit> git restore <file> reset vs revert (destructive vs safe) Stash Use Cases
What You Will Be Able to Do
  • Stash unfinished work so you can switch branches without committing incomplete changes
  • Manage multiple stash entries and bring back exactly the one you need
  • Undo the last commit while keeping your file changes available to recommit differently
  • Safely reverse a commit that is already on a shared branch using git revert
  • Discard file changes that you have not committed yet and restore the last clean version
  • Know exactly which undo method to use in each situation — and which ones to avoid on shared branches
MODULE 09 Collaboration — Pull Requests & Code Reviews
WHY THIS MODULE

Pull requests are the heartbeat of every collaborative software project. Nobody pushes directly to main in a professional environment — every change goes through a PR, gets reviewed by at least one other person, and is only merged when it meets the team's quality standards. If you cannot create or review a PR, you cannot contribute to a real team project. This module teaches you both sides of that workflow.

Key Topics Covered
Pull Request (PR) PR Title & Description Reviewers & Approvers Code Review Comments Approve / Request Changes Merge after Approval Branch Protection Rules Forking Workflow Squash Merge Draft PRs
What You Will Be Able to Do
  • Create a pull request from your feature branch to main on GitHub
  • Write a clear PR title and description that helps reviewers understand what changed and why
  • Assign reviewers and configure required approvals before the PR can be merged
  • Review another person's code, leave line-level comments, and approve or request changes
  • Merge a PR after all approvals are received and all checks pass
  • Set up branch protection rules to enforce the review process on protected branches
MODULE 10 Advanced Git Operations
WHY THIS MODULE

These are the commands that separate intermediate Git users from advanced ones. Rebase gives you the ability to present your work as a clean, professional commit history instead of a messy sequence of "fixed typo" and "still fixing" commits. Cherry-pick lets you move individual fixes between branches without merging everything. Tags mark official releases. These are real skills that come up in senior developer and senior tester interviews.

Key Topics Covered
git rebase <branch> git rebase -i HEAD~N Squash / Edit / Reorder commits git cherry-pick <hash> git tag v1.0 git push origin --tags Annotated vs Lightweight Tags git blame git bisect Rebase vs Merge Trade-offs
What You Will Be Able to Do
  • Rebase a feature branch onto the latest main to produce a clean, linear project history
  • Use interactive rebase to squash or tidy up a series of messy commits before sharing them
  • Cherry-pick a specific commit from one branch and apply it to another without merging everything
  • Tag a specific commit as a release version (e.g. v1.0) and push tags to GitHub
  • Find out exactly who last changed any line of code and when using git blame
  • Locate a bug-introducing commit efficiently using git bisect's binary search approach
MODULE 11 IDE Integration — VS Code & PyCharm
WHY THIS MODULE

Most developers and testers spend their entire day inside VS Code or PyCharm. Being able to run Git operations without switching to a terminal saves enormous time and removes friction from your workflow. More importantly, visual merge conflict resolution in VS Code is significantly easier than resolving conflicts in plain text — you can see both versions side by side and click to choose. This module makes Git feel like a natural part of your IDE rather than a separate tool.

Key Topics Covered
VS Code Source Control Panel Stage / Unstage / Commit in VS Code Branch in VS Code Status Bar Visual Merge Conflict Resolution GitLens Extension PyCharm VCS Menu Commit / Push from PyCharm GitHub Desktop GUI Terminal vs GUI Decision
What You Will Be Able to Do
  • Stage, commit, and push changes entirely within VS Code's Source Control panel
  • Resolve merge conflicts visually using VS Code's side-by-side comparison editor
  • Create and switch branches directly from the VS Code status bar
  • Commit, push, pull, and manage branches from PyCharm's VCS menu without opening a terminal
  • Use GitHub Desktop as a fully visual alternative for teams that prefer a GUI workflow
  • Know when the terminal is still the better choice and when the IDE GUI is faster
MODULE 12 GitHub Actions, Webhooks & CI/CD
WHY THIS MODULE

In modern teams, tests do not wait for someone to remember to run them — they run automatically on every single commit. GitHub Actions is how that happens. A tester who understands CI/CD can set up a pipeline that catches bugs the moment code is pushed, notifies the team instantly, and ensures nothing broken ever reaches production. This is one of the highest-value skills a QA engineer can have, and it is directly built into GitHub.

Key Topics Covered
GitHub Actions Overview Workflow YAML File .github/workflows/ on: push / pull_request triggers Jobs, Steps & Runners Actions Marketplace Webhooks & Event Triggers Jenkins + GitHub Integration Bitbucket Pipelines GitHub Secrets
What You Will Be Able to Do
  • Create a GitHub Actions workflow YAML file to automate tasks whenever code is pushed
  • Set up automatic test execution on every push or pull request to a branch
  • Configure jobs, steps, and runners to define exactly what the automation does and where it runs
  • Set up webhooks to trigger notifications or actions in external tools when GitHub events occur
  • Integrate GitHub with Jenkins so Jenkins can automatically trigger builds on code push
  • Store sensitive credentials safely using GitHub Secrets so they are never visible in your code files

Interview Preparation Tips

Merge vs Rebase

Merge preserves full history including the branch join point. Rebase replays commits onto a new base for a clean linear history. Use merge for shared/protected branches, rebase for feature branches before review.

git pull vs git fetch

git fetch downloads remote updates without applying them — safe for inspection. git pull = fetch + merge in one command. Use fetch when you want to review what changed before integrating.

Reset vs Revert

git reset rewrites history (only safe before sharing). git revert creates a new "undo" commit — safe on shared branches because it never deletes history, only adds a corrective commit.

What is git stash?

Stash saves your uncommitted work to a temporary shelf so your working directory is clean. You can switch tasks, then come back and restore your saved work with git stash pop exactly where you left off.

Cherry-pick — when to use it?

When a hotfix commit needs to go to both main and a release branch — without merging all the other work in between. Cherry-pick copies that one specific commit to any branch you choose.

Branch Protection Rules

Branch protection blocks direct pushes to main and requires PRs with passing checks and minimum approved reviews. It is the key mechanism that enforces code quality in CI/CD workflows.

Git Fundamentals — Revision Topics
  • git add / commit / push cycle
  • git log --oneline recap
  • Branch create & switch commands
  • Merge vs Rebase quick reference
  • Conflict resolution steps
  • SSH key setup checklist
  • Pull Request workflow steps
  • git stash commands summary