certuvia teaches Git differently. Every lab starts with a realistic scenario — you discover why the command exists before you touch it. A live Linux environment with real Git runs in your browser. All 71 labs are available; browse the complete curriculum below.
"I can work alone, track my own work, and know what's happening at all times."
"I can join a team repo, work on branches, resolve conflicts, and ship through pull requests."
"I can rewrite history safely, debug with bisect and blame, and recover from anything."
You are starting a personal project — a recipe collection. You want Git to track your work so you can look back later at what changed and why.
Git won't work with a stranger. Before it stamps a single commit, it needs to know who you are.
Create a project folder, run git init, and see exactly what changes on disk. Git is just files — not magic.
Create a file, stage it, and ask the honest question: if this VM crashed right now, is this file actually safe?
Commit the staged recipe, and see exactly what a permanent snapshot looks like — not a save button, a checkpoint with a real identity.
Your recipe project grows. Over one afternoon you edit three files. You want your Git history to be readable, not just a dump of "updated stuff."
Edit three real files at once. A commit is a choice — not "all the changes I happened to make."
A provided sample history genuinely mixes good and bad messages. Learn to tell them apart — and to write the good kind yourself.
Edit the same real file in two separate places. Stage only one hunk. This is a real power move most developers learn years too late.
A colleague asks: "When was the butter quantity added, and who last changed it?" Answer in under 30 seconds — tools only, no scrolling.
You want to experiment with a spicy new section of your recipe book without risking the existing work. Branches are your sandbox.
Create a real branch, commit on it, switch back to master. Master never moves — confirmed directly, not just described.
Open .git/refs/heads/ directly. A branch is genuinely just a text file holding a commit hash — nothing more.
Halfway through an edit, you need to check something on another branch. Git's real error message is informative — but scary the first time.
Eight genuinely vague branch names. Rewrite them so a teammate could understand each one's purpose without asking.
You've made a series of mistakes. Each mission is a different kind of mistake with a different kind of fix. None of them are catastrophic — once you know the tools.
A private scratch file got staged by accident. Unstage it without losing a single word of it.
A real typo in the message, and a real forgotten file. Fix both at once, before anyone else ever sees either.
A real file, genuinely corrupted. Restore it to the last commit — or to any earlier one you choose.
The same real commit, undone three different ways. Feel exactly what soft, mixed, and hard reset each really do.
You want to back up your recipe book online and share it with a friend. You set up a remote, push your work, and understand what's actually happening when you do.
A lock and a key, not a password. Build the real file model before you ever touch GitHub.
Real clutter, a real secret, and a .gitignore that should have existed from commit one.
A real remote — even a local one works exactly like GitHub underneath. Push to it for real.
Someone else commits somewhere else. See exactly what git fetch shows you — and what it deliberately leaves untouched.
You're joining a team mid-project. The repo exists. You need to understand its state, set yourself up, and start contributing without stepping on anyone.
A real team repo, cloned for the first time. Map its entire real history before touching anything.
A real teammate commits while you're away. See exactly what fetch shows you — and what pull actually does about it.
A teammate's feature branch exists only on the remote. Track it, commit, push — and see a real push failure, then fix it.
Master keeps moving while you work. Catch up two real ways — merge and rebase — and compare the resulting graphs directly.
Your team has a shared main branch that must always be deployable. You develop everything on feature branches.
Branch, commit, push, review, merge, clean up, sync. The complete real lifecycle, with no shortcuts.
A real branch that lived far too long. Measure exactly how far it drifted, in both directions.
Two real features, the same shared file. Plan the merge order, then resolve the real conflict that follows anyway.
Six real branches, three real categories. Clean up every single one with the right real command.
The team's branches diverge in different ways. Learn to predict and influence how Git will integrate them.
Predict before you run it. Then force the opposite outcome on purpose, and see exactly why teams do that.
Both sides genuinely moved. Trace the real common ancestor by hand before git does the actual three-way merge.
Nine genuinely messy commits. One clean, real story on master — and the branch's own history, deliberately left behind.
Four real scenarios. Four real strategies. The right choice depends entirely on what actually happened.
Two developers changed the same file. Git can't auto-merge. Now what?
A real, genuine conflict in two files. Decode exactly what each side changed, directly from the raw markers.
Both real conflicts, resolved by hand. git status confirms exactly what's left, every step of the way.
No real GUI here — but the exact same base/ours/theirs view, using nothing but plain, real git commands.
A real conflict, mid-rebase — resolved one commit at a time. Then a real escape hatch when you'd rather just stop.
This block's own real conflicts, reviewed for the patterns that caused them — prevention beats resolution.
No GitHub in this sandbox — so this block teaches the real git mechanics a PR interface is built on top of.
A real branch, open since Lesson 2.1.1 and never reviewed — finally getting a real PR.
A real, separate PR from a teammate — reviewed with the same real commands any review UI is built on.
Real feedback landed on YOUR OWN PR this time. Two real, genuinely different ways to respond to it.
A real, genuine server-side hook enforces the rule — then both real PRs finally get merged the right way.
Something went wrong on a branch others are using. Fix it without breaking their work.
A real, genuine mistake reached master. Undo it by adding history, never by removing it.
An entire real feature needs to be backed out — not just one line, the whole thing.
A real teammate's work, genuinely at risk. See --force actually destroy it — then the safer real alternative.
Two real accidents, two genuinely different real recoveries — both landing the normal, reviewed way.
Your branch has 11 commits including "WIP", "asdf", and "really trying to fix this now." Before opening a PR, clean it up.
Four real "WIP" commits. One meaningful commit. A real, scripted interactive rebase makes it happen.
A real, unrelated fix accidentally rode along in the wrong commit. Split it out, then reorder two others.
Commit 4 of 6 has the wrong ticket number. Fix it without touching anything else — except every hash after it.
This is about discipline, not commands. A real, written policy, landed the normal way.
A real branch, accidentally built on a stale one. Transplant it directly onto the real correct base.
Production is broken. The fix already exists on another branch. You need exactly that one commit.
A real, genuine food-safety error. It needs to reach two already-published branches, today.
Three real commits, one complete feature. Bring all three over at once — and handle the real conflict along the way.
No push access. No shared remote. A real patch file is all it takes.
check-times.sh started failing. You don't know which of the last 50 commits broke it.
check-times.sh started failing. Somewhere in the last 50 commits, one of them broke it.
The same kind of regression, a second time. This time, git drives the entire real search itself.
A shared file, three real teammates, one genuine "magic number." Who changed it, and why?
Four real, different questions. Four real git log flags, each built exactly for one of them.
A series of real mistakes. In every single case, the real work is still there.
A commit was discarded. A branch was force-pushed over. git remembers both.
Four real commits. One genuinely deleted branch. Recovered in full.
Three real commits. One destructive reset. Recovered in a single command.
Three real commits, made in detached HEAD. Rescued before switching away would strand them.
A real rebase, conflict and all, completed — then undone entirely, in one command.
The project has grown. Structure — tags, stash, submodules — stops being optional.
A real lightweight tag. A real, fully annotated release. Genuinely different objects.
Three real interruptions. Three genuinely different ways to use git stash.
A real shared library, pinned to an older commit. Time to genuinely catch it up.
A real binary asset, genuinely bloating the repo. The real fix — and an honest tooling gap.
The same real mistakes, over and over. Time to automate the prevention.
A real commit, genuinely rejected for missing a ticket reference. Then genuinely accepted.
A real staged file with a stray TODO. A real .env file. Both genuinely blocked before they land.
A real CRLF file, already committed. Normalized to LF for good, confirmed byte by byte.
Five real, personal aliases. Each one genuinely tested, not just configured.
A real pipeline spec, written and committed. Every git event mapped to a real automated response.