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.
Outline points are grouped in one designed block instead of being treated as separate module cards.
01The Git Object Model and Local Workflow4 topics
- 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
02Branching Strategies for Real Delivery Schedules4 topics
- 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
03Merging, Rebasing, and Conflict Resolution4 topics
- 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
04Pull Requests and Code Review Practice4 topics
- 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
05Recovery, History Repair, and Repository Hygiene4 topics
- 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
06Team Convention Workshop4 topics
- 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