DevOps · DOP-08

Git, GitHub and Azure Repos for Teams

Git, GitHub and Azure Repos for Teams is a hands-on course in using Git in depth and as a team, from branching, merging and resolving conflicts to interactive rebase, bisect and reflog, then pull requests, code review, rulesets and branch policies on GitHub and Azure Repos. It suits software developers, tech leads and teams working on GitHub or Azure DevOps who want shared standards.

Updated 20 Oct 2026

From 6,210 THB / person 6,900 −10% excl. VAT 7% · group rates available

Corporate training quote Join the waiting list

PDFDownload the course outline

Duration12 hours · 2 days
FormatOnsite / live online
Next roundOn request
LevelIntermediate

Course overview

Many software teams still run into the same problems: overwritten code, lost files, no clear record of who changed what, merges that break the build and a commit history too messy to audit, because members only know basic Git commands without understanding what happens underneath, so they avoid advanced commands when things go wrong. Many organisations also use GitHub and Azure DevOps side by side, so teams need to understand both platforms and how each one protects code quality.

Day 1 builds a solid Git foundation, from how Git works internally to branching, merging and resolving conflicts, then moves on to deeper tools such as interactive rebase, cherry-pick, bisect and reflog for tidying history and recovering work with confidence. Day 2 moves on to teamwork on GitHub and Azure Repos with pull requests, code review, rulesets and branch policies, comparing the two platforms step by step. Learners work in groups on the TeamBoard Web project, hit real conflicts and review each other's code, so they can set up team standards straight after the course. (2 days, 6 hours a day, 12 hours in total, Beginner to Intermediate level.)

What you’ll gain

Understand how Git works inside: the working directory, the staging area, the repository and the object model
Use the Git commands needed day to day, from the command line and from VS Code
Create branches, merge, rebase and resolve merge conflicts with confidence
Tidy history with interactive rebase and cherry-pick, find the cause of bugs with bisect and recover work with reflog
Work with remote repositories on GitHub and Azure Repos
Use pull requests and code review to work as a team to a consistent standard
Set up rulesets, branch protection and branch policies to control code quality
Choose a branching strategy and agree working rules that fit your own team

Who this course is for

Software developers in any field who want to use Git correctly with their team
Developers who only know basic Git commands and want a deeper understanding
Tech leads and team leads who want to set pull request and code review standards
Teams using, or moving between, GitHub and Azure DevOps
QA, DevOps and system administrators who work with the development team's repositories

Prerequisites

Comfortable using a computer and managing files and folders
Basic use of the command line or a terminal
Basic programming or code editing experience in any language
A GitHub account (Free is enough) and a Microsoft account to create a free Azure DevOps organisation
No previous Git, GitHub or Azure DevOps experience is needed; existing Git users will deepen their understanding and pick up team-level practices

Curriculum

Course Details

A 2-day hands-on course, 6 hours a day and 12 hours in total (09:00-16:00), at Beginner to Intermediate level for people with basic command-line skills, using Git 2.56 or later, Visual Studio Code, GitHub and Azure Repos. Day 1 covers Git from the basics to its deeper tools; day 2 covers teamwork on GitHub and Azure Repos. Learners use their own GitHub account and Microsoft account (free tiers are enough); the institute does not provide

accounts. Unlike Git, GitHub and Bitbucket for Beginners, a 2-day foundation course, this course goes deeper into Git internals, interactive rebase, bisect and reflog, then focuses on teamwork through pull requests, code review and branch rules on GitHub and Azure Repos. Learners take home the course handbook, the TeamBoard Web sample project with lab guides, a Git cheat sheet with recovery steps, and a sample branching strategy, commit convention, Git hook, pull request template and pull request checklist for their team.

Day 1 Git from the Basics to Its Deeper Tools

Section 1: Lab: Git Fundamentals and Git Internals

Distributed version control and the working directory, staging area and repository
Configure Git with git config and use the core commands init, status, add, commit, log and diff, plus .gitignore
Writing good commit messages and the Conventional Commits format
The Git object model (blob, tree, commit, tag), together with references, branches and HEAD
Lab: create the TeamBoard Web repository, then inspect the objects in .git with git cat-file

Section 2: Lab: Branching, Merging and Conflict Resolution

Create and switch branches with git switch and git branch
Fast-forward merge, three-way merge and rebase, and when to use each
Resolve conflicts from the command line and in VS Code, then stage them with git add --resolved (Git 2.56)
Clean up merged branches and use tags to mark versions
Lab: create a conflict between two branches and resolve it correctly both ways

Section 3: Lab: History Rewriting for a Clean History

Fix the latest commit with git commit --amend
Interactive rebase (git rebase -i): squash, fixup, reword, reorder and drop
Apply selected commits to another branch with git cherry-pick
The golden rule: rewrite history only on private branches, and push safely with --force-with-lease
Lab: squash a messy set of commits into a readable series before handing in work

Section 4: Lab: Debugging History, Recovery and Git Hooks

Advanced log filtering and graph view, git blame, git log -S and git grep
Find the commit that introduced a bug with git bisect, step by step and automatically with git bisect run
git restore, git stash and the difference between revert and reset (soft, mixed, hard)
Recover lost commits or branches with git reflog
Client-side Git hooks such as pre-commit and commit-msg to check work before committing

Section 5: Day 1 Workshop: TeamBoard Web on Your Own Machine

Clone a prepared repository with a messy commit history and a hidden bug
Build a new feature on a separate branch, then create and resolve a merge conflict
Tidy the history with interactive rebase and use git bisect to find the commit that broke the page
Workshop: recover a deleted branch with reflog and install a hook that checks the commit message format

Day 2 Teamwork on GitHub and Azure Repos

Section 6: Remote Repositories and Your Team's Branching Strategy

clone, remote, fetch, pull and push, upstream branches, and setting pull to merge or rebase
Authenticate with an SSH key or over HTTPS with Git Credential Manager, multiple remotes and forks
Compare GitHub Flow, trunk-based development and Git Flow by team size and release cadence
Team agreements: branch names, commit convention, PR size, who reviews and how to merge
Lab: connect the same repository to GitHub and Azure Repos and push to both

Section 7: Lab: Pull Requests and Code Review on GitHub

Create a repository, invite members and manage repository and organisation permissions
Pull requests, draft pull requests and reviews: comment, suggest changes, request changes and approve
Merge methods (merge commit, squash, rebase) and their effect on repository history
Good code review practice, and an overview of Copilot code review (requires a paid Copilot plan)

Section 8: Lab: GitHub Governance and GitHub Projects

Rulesets and branch protection: require reviews, block force pushes and require status checks
CODEOWNERS, pull request templates and issue templates
Link pull requests to issues and track work with GitHub Projects
Lab: set up a ruleset and CODEOWNERS, then open a draft pull request for a teammate to review until it is ready to merge

Section 9: Lab: Azure Repos and How It Compares with GitHub

How organisations, projects and repositories fit together, required and optional reviewers, and auto-complete
Branch policies: minimum number of reviewers, linked work items, comment resolution and build validation
Link work to work items in Azure Boards
Map rulesets to branch policies and issues to work items, with ways of working across both platforms
Lab: set branch policies, then open a pull request linked to a work item and set auto-complete

Section 10: Master Workshop: Working as a Team to the First Release

In groups of 3-4, put TeamBoard Web on GitHub and Azure Repos and agree the team's working rules
Set up rulesets, CODEOWNERS and branch policies, then split the work so each member builds a feature
Open pull requests linked to an issue or work item, review teammates' work and resolve real conflicts
Wrap up a pull request checklist and the working standards to take back to your team
Workshop: merge every feature into the first release with a version tag on both platforms

Schedule & training options

For individuals — public rounds

No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770

Join the waiting list Ask about rounds

For organisations — in-house / private

Tailor the content to your team’s tools and projects
Your dates, at your office or live online
Quotation with tax ID for procurement

Corporate training quote

Instructors

Samit KoyomFounder & CEO, IT Genius Engineering

Frequently asked questions

How does this course differ from Git, GitHub and Bitbucket for Beginners?

Git, GitHub and Bitbucket for Beginners is a 2-day foundation course for newcomers that focuses on basic Git commands, using GitHub and Bitbucket. This course is also 2 days but goes deeper into Git, covering its internals, interactive rebase, cherry-pick, bisect and reflog, then spends the second day on teamwork through pull requests, code review and branch rules on GitHub and Azure Repos. If you are completely new and only want the basics, choose the foundation course. If your team works on GitHub or Azure DevOps and wants deeper Git skills and shared standards, this course is the better fit.

Do I need previous Git experience?

No. Day 1 builds Git from the ground up before moving on to the deeper tools, but you should be comfortable with basic command-line use and have edited code files before so you can keep pace over both days. Existing Git users will deepen their understanding and pick up team-level practices.

Which accounts do I need, and does the institute provide them?

You bring your own free GitHub account and a Microsoft account to create a free Azure DevOps organisation. The institute does not provide accounts. Please create the accounts and install Git and Visual Studio Code before the first training day.

Do I need a paid GitHub or Azure DevOps plan?

No. The GitHub workshop uses public repositories, where rulesets and branch protection work on a free account. Azure DevOps Services includes a number of free Basic users per organisation, which is enough for a group of 3-4. Copilot code review is shown as an overview only, so you do not need a Copilot plan.

Does the course cover CI/CD with GitHub Actions or Azure Pipelines?

Not in depth. CI is covered only as status checks in rulesets and build validation in branch policies, and the course does not cover large monorepos, Git submodules, Git LFS or migrating repositories between platforms. To go further with pipelines, consider Pro Automation with Jenkins, GitHub Actions and n8n, or GitOps with Argo CD.

Can this be run in-house for our team on our own GitHub or Azure DevOps?

Yes. The institute runs in-house sessions and can adjust the balance between GitHub and Azure Repos to match the platform your team uses; contact us for a quotation. The workshops still use the sample project and mock data rather than your organisation's real source code.

Articles are published in Thai.