Git Trainings

How many times have you broken a merge this year?

The question is rhetorical. Git is used by virtually all developers, data scientists, DevOps engineers and increasingly data analysts. Yet, in most teams, actual use stops at add-commit-push, with a GitHub Desktop or IDE hiding the machinery. The day the merge goes sideways, the history turns to spaghetti, a cherry-pick is needed on a forgotten branch, or a colleague rebases on main while you work on it, the absence of a clear mental model of Git costs dearly.

A well-structured Git course is not a luxury for senior developers. It is a short investment (a few days) that pays back across the whole professional life of a tech profile. Understanding Git’s model (objects, references, index, working tree) is enough to unblock the vast majority of complex situations.

The Git catalogue at ITTA

Git Fundamentals

Git – Fundamentals is our core Git course. It covers: Git data model (objects, references, refs, index), essential commands (init, clone, add, commit, status, log, diff), branches and merges, rebase (and when to prefer it to merge), conflict handling, tags and releases, remote (push, pull, fetch), common workflows (GitFlow, GitHub Flow, Trunk-Based Development), error management (reset, revert, reflog), stash, cherry-pick, bisect, and first notions of hooks. The course is calibrated to move from blind add-commit-push to real operational mastery.

Git workflows in depth

GitFlow: the historical workflow

GitFlow offers a structured model with develop, feature/*, release/*, hotfix/* and main branches. It suits organisations doing planned releases and needing to isolate stabilisation phases. Still dominant in finance, embedded and some enterprise applications. The cost is some heaviness.

GitHub Flow: simplicity by default

GitHub Flow simplifies to a single rule: main is always deployable, work happens on feature branches, merge via Pull Request. Default workflow for most open source projects and scale-ups. Ideal for continuous flow, frequent deployment.

Trunk-Based Development: the high-frequency path

TBD goes further: everyone works on main (or very short branches under one day), with feature flags hiding unfinished features. Heavily used at Google, Meta, Netflix, this is the preferred path for teams wanting very fast CI/CD.

Our course addresses all three workflows and helps choose based on context (team size, release frequency, CI/CD maturity). There is no universal right answer.

Git in the ITTA dev ecosystem

Git fits a broader catalogue. The software development tools sub-domain groups our training on transverse tools. The CI/CD sub-domain covers continuous integration and deployment pipelines built on Git. For DevOps teams, the cross with DevOps and container sub-domains is systematic.

On the publisher side, you will find GitLab for the full DevOps platform, GitHub Copilot for the AI coding assistant integrated to GitHub, and Open Source grouping libre technologies including Git.

Git trends in 2026

Git 2.45 and following consolidate features on the monorepo side (partial clone, sparse checkout), improve performance on very large repositories and finalise SHA-256 (progressive transition from SHA-1). On the platform side, GitHub, GitLab and Bitbucket continue their consolidation. On the AI side, GitHub Copilot and IDE-integrated AI assistants generate a growing share of code, changing the relationship to commits (smaller, more explanatory, more human review). PR/MR workflows generalise everywhere.

Sharp technical Git FAQ

Rebase or merge on a feature branch to merge to main?

Both have their place. Rebase produces a linear, more readable history, to favour on short feature branches before final merge. Merge with –no-ff keeps the branch trace, useful for important features. Golden rule: never rebase an already shared and published branch, unless coordinated with the whole team. Our course covers these cases in practice.

How to recover a lost commit after a reset –hard?

git reflog is your friend. The reflog keeps trace of all HEAD movements for 90 days by default, even commits “lost” after a reset –hard or a botched rebase. You find the lost commit SHA and re-check it out. One of the most reassuring topics in class: Git forgives more than people think.

Cherry-pick of an urgent fix from main to a release branch: best practices?

Cherry-pick remains the appropriate tool to port an isolated commit between branches. Classic pitfall: drift if several cherry-picks accumulate (SHAs diverge, diffs become confusing). Discipline: limit to urgent fixes, mark cherry-picked commits with a clear message, and synchronise the release branch with main as soon as possible.

What strategy for multi-gigabyte monorepos?

Git supports very large repos with partial clone, sparse checkout and more recently Scalar (integrated at Microsoft for Windows and VFS). For extreme monorepos (Google, Meta scale), complementary solutions exist (Bazel, Buck, Nx). Our course addresses best practices for typical Swiss enterprise monorepos.

Should we commit local configuration files in .gitignore?

General rule: no. Secrets (.env, passwords, API keys) must be outside the repo and provided by environment variables or secret manager. Local configurations (.vscode.idea) are sometimes ignored, sometimes committed by team convention. Initial discipline saves hours of debugging.

What you leave with at the end of a Git Fundamentals session

After the course, you leave with a clear mental model of Git (objects, refs, index, working tree), operational reflexes on essential commands, an understanding of the three major workflows (GitFlow, GitHub Flow, Trunk-Based) and the ability to choose the right one for your context, recovery techniques for errors (reflog, reset, revert, cherry-pick), and a professional commit posture (clear messages, reasonable size, separation of concerns).

Operationally, you gain autonomy facing “Git panic” situations that waste the whole team’s time: complex conflict, broken history, lost branch, failed merge. This autonomy has immediate value for you and for colleagues you no longer need to ask at every incident.

Featured Git course

• Git – Fundamentals

Git sessions in Geneva, Lausanne and virtual

Our Git sessions are available in Geneva, Lausanne and interactive virtual classroom with an active developer as trainer. For teams looking to harmonise their Git practice (for instance moving from GitLab to GitHub, or from GitFlow to GitHub Flow), in-house delivery lets us work directly on your team convention and typical repositories.

Git in a team: conventions that make the difference

Individual Git usage is one thing; team usage is a topic of its own. Our Git courses cover the conventions that structure a productive team. Commit message convention: a clear format (Conventional Commits for instance: feat:, fix:, docs:, refactor:) enables automatic changelog generation, filtering commits by type and improving history readability. Collective discipline on this topic has real value for long-term maintenance.

Branch convention: main for production, develop for integration (in GitFlow), feature with ticket id and short name for features, hotfix for urgent fixes. Conventions facilitate repo reading and automate CI/CD hooks. Code review convention via Pull Request or Merge Request: who reviews, in how much time, validation criteria, how to handle disagreements. Our courses cover these topics, which go beyond technical tooling but condition real team productivity. On the CI/CD side, Git is at the heart of modern pipelines. Each push triggers hooks (lint, unit tests, build, staging deploy) based on configuration. Git mastery facilitates reading and debugging CI/CD pipelines when a job fails unexpectedly. Our courses address this Git plus CI/CD intersection presenting usual patterns on GitHub Actions, GitLab CI and Bitbucket Pipelines.