Software Development
Git and Version Control for Development Teams
A practical Git course for development teams that need one reliable, shared way of working. Participants learn the Git object model, branching and merging strategies, pull-request review, conflict resolution, history repair, and the repository conventions that keep parallel work safe and traceable.
Overview
Practical learning for workplace transfer.
Most teams learn Git as a list of commands and discover the gaps only during a bad merge, a lost branch, or a release that cannot be traced back to its code. This course rebuilds the mental model first — commits, trees, refs, and the difference between rewriting and reconciling history — then applies it to the situations that actually cost delivery time: long-lived branches, review bottlenecks, hotfixes against a released tag, and recovering work that appears to be gone. Participants leave with a written branching and review convention their team can adopt on the next sprint.
Prerequisites
Comfort with a command line and basic software development experience. No prior Git knowledge is assumed.
Objectives
- Explain the Git object model and what a commit, tree, ref, and HEAD actually represent.
- Select a branching strategy that matches the team's release cadence and review capacity.
- Resolve merge and rebase conflicts without losing work or corrupting shared history.
- Run pull-request reviews that surface defects early and keep delivery moving.
- Recover lost commits, branches, and detached work using reflog and recovery commands.
- Document a repository convention covering naming, commits, tags, and protected branches.
Target audience
- Software developers and engineers working in shared repositories
- Technical leads and code reviewers
- QA, DevOps, and release engineers
- Data and automation engineers who version code and notebooks
- Engineering managers standardizing team workflows
- Teams migrating from centralized version control to Git
Program outline
A clear structure for the learning journey.
Program outline
Outline points are grouped in one designed block instead of being treated as separate module cards.
Module 1: The Git Object Model and Local Workflow
Commits, trees, blobs, refs, and HEAD explained through the actual object store
Working tree, staging area, and commit: what each command really moves
Writing commit messages that survive as release and audit evidence
Inspecting history with log, diff, blame, and bisect
Module 2: Branching Strategies for Real Delivery Schedules
Trunk-based development, GitHub Flow, and release-branch models compared
Matching branch lifetime to review capacity and integration risk
Feature flags as an alternative to long-lived branches
Tagging, versioning, and tracing a release back to its commits
Module 3: Merging, Rebasing, and Conflict Resolution
Merge versus rebase: when each is safe and when it rewrites shared history
Reading a conflict, choosing a resolution, and verifying the result
Interactive rebase for squashing, reordering, and cleaning a branch
Cherry-pick, revert, and reset: choosing the right correction
Module 4: Pull Requests and Code Review Practice
Sizing changes so reviews stay fast and defects stay visible
Review checklists, required approvals, and protected-branch rules
Giving and receiving review feedback without stalling delivery
Automated checks that must pass before a merge is allowed
Module 5: Recovery, History Repair, and Repository Hygiene
Reflog, dangling commits, and recovering work that appears lost
Removing secrets and large files from history safely
Submodules, monorepos, and large-repository performance
gitignore, hooks, and repository configuration standards
Module 6: Team Convention Workshop
Diagnosing the team's current branching and review pain points
Drafting naming, commit, tag, and protection rules
Simulating a hotfix against a released tag under time pressure
Agreeing the convention, its owners, and the adoption steps
Materials provided
- Course workbook, annotated code samples, and reference notes
- Hands-on lab environment and starter repositories
- Exercises, checklists, and reusable code templates
- 4D Certificate of Completion
- Post-course technical guidance
Training Options
Programs can be delivered in-house, online, or in a blended format depending on your team's schedule, location, and learning objectives. When an external certificate or exam is included, certification rules and fees remain under the relevant awarding body's policies, while 4D provides the training and preparation support.
Why choose 4D
4D delivers this course against your actual repositories, branching pain points, and release cadence rather than a generic demo project. Trainers work with development, QA, and release stakeholders in the same room, so the convention agreed in the closing workshop is one the whole team can apply on the next sprint.
Related courses
Python Programming Fundamentals
A hands-on introduction to Python for engineers and analysts who need working code rather than tutorial fragments. Participants build fluency with data types, collections, functions, files, and error handling, then assemble a small program that reads real data and produces a usable report.
View courseIntermediate Python and Clean Code Practices
Designed for developers whose Python works but is difficult to change. The course covers dataclasses, generators, decorators, context managers, and type hints, then applies the refactoring moves that turn a nine-hundred-line module into small tested units guarded by black, ruff, and mypy.
View coursePython Automation and Scripting for Work Tasks
Aimed at teams losing hours every week to repetitive file, spreadsheet, and reporting work. Participants automate those tasks with Python: batch file handling, Excel and CSV processing, REST API calls, email alerts, and scheduled jobs that run unattended and report clearly when something fails.
View course