If you are an X++ developer working on Dynamics 365 Finance & Operations, chances are you started your journey with TFVC. For many years, TFVC was the default and it did the job well.

But the D365 F&O platform is changing.

With Unified Development Environments (UDE) and Power Platform Admin Center (PPAC) becoming part of the standard setup, the way we develop, manage, and deploy code is evolving. And in this new world, Git fits naturally.

This blog explains—using simple, real-world language—why learning Git is important for X++ developers, how it compares to TFVC, and why Git aligns so well with UDE and PPAC.

---

A Simple Truth First

This shift is not because TFVC is “bad”.

It’s because:

• TFVC was designed for an older development model
• Git is designed for modern, cloud-first, automated development

Microsoft is clearly moving D365 F&O toward the second model.

---

How TFVC Works (and Why It’s Starting to Feel Heavy)

TFVC is a centralised version control system.

In simple terms:

• There is one central server
• Everyone connects to it
• Files are often locked when someone works on them
• The environment plays a big role in protecting code

This worked well when:

• Teams were small
• There were fewer parallel changes
• Dev boxes were long-lived and carefully managed

But today, it creates friction:

• Developers block each other
• Branching feels complex and slow
• Automation is harder
• Environments become precious and fragile

In short:

TFVC is tightly coupled with the environment.

---

How Git Thinks (and Why It Feels Lighter)

Git is distributed.

That means:

• Every developer has a full copy of the code
• You work in your own branch
• You don’t lock files
• You don’t block others

Instead of protecting code with environments, Git protects code with branches and reviews.

This makes Git feel:

• Faster
• Safer
• More flexible
• Better suited to automation

---

The Big Mindset Shift for X++ Developers

TFVC mindset

• “My Dev box has my changes”
• “Don’t touch this object, I’m working on it”
• “If the environment breaks, I’m stuck”

Git mindset

• “The repository is the source of truth”
• “My work is isolated in my branch”
• “If the environment breaks, I rebuild it”

This mindset is exactly what UDE and PPAC are designed for.

---

Git vs TFVC – Simple Comparison

Area	TFVC	Git
Control model	Centralised	Distributed
File locking	Common	Not needed
Branching	Heavy	Lightweight
Parallel work	Limited	Excellent
Automation	Harder	Natural fit
Environment dependency	High	Low
Fit for UDE & PPAC	Weak	Strong

---

Common Commands: TFVC vs Git (Same Goal, Different Words)

One common fear is:

“I know TFVC commands. Git feels confusing.”

Here’s the reality: most actions are the same, just expressed differently.

Getting Code

What you want to do	TFVC	Git
Download code first time	Get	git clone
Get latest changes	Get Latest	git pull

---

Starting Work

What you want to do	TFVC	Git
Start editing	Check out	Create a branch
Prevent conflicts	Lock files	Isolate work in branch

Git removes the need to lock files because everyone works independently.

---

Saving Your Work

What you want to do	TFVC	Git
Save changes	Pending changes	git commit
Save without sharing	Not really possible	Fully supported

Local commits are one of Git’s biggest productivity boosters.

---

Sharing Your Work

What you want to do	TFVC	Git
Submit code	Check-in	git push
Review code	Optional	Pull Request (standard)

In Git, code review is part of the normal flow, not an exception.

---

Temporary Storage

What you want to do	TFVC	Git
Park unfinished work	Shelve	git stash
Resume later	Unshelve	git stash pop

---

Undoing Mistakes

What you want to do	TFVC	Git
Undo local changes	Undo checkout	git restore
Reverse committed code	Rollback	git revert

Git gives you more control and safer recovery options.

---

Why Git Fits Perfectly with UDE

UDE is built around a few key ideas:

• Environments should be rebuildable
• Code should not live only in Dev boxes
• Pipelines should do the heavy lifting
• Manual steps should be reduced

Git supports this naturally because:

• The repository is the single source of truth
• Builds are repeatable
• Environments become replaceable, not precious

With Git:

Losing a Dev environment is inconvenient, not catastrophic.

---

Why Git Works So Well with PPAC

PPAC focuses on:

• Centralised environment governance
• Controlled deployments
• Standardised ALM

Git complements this by:

• Managing source code cleanly
• Enforcing approvals via pull requests
• Supporting automated validation and builds
• Keeping a clear audit trail

Think of it this way:

• PPAC manages environments
• Git manages code

Each does its job well, without overlap.

---

How X++ Developers Can Start (Without Stress)

You don’t need to learn everything at once.

Start with:

1. Clone a repository
2. Create a branch
3. Make small commits
4. Push changes
5. Raise a pull request

That’s enough to be productive.

The rest will come naturally with practice.

---

Final Thoughts

TFVC helped D365 F&O teams for many years.
But the platform is clearly moving forward.

With:

• UDE becoming standard
• PPAC managing environments
• Automation becoming the norm

Git is no longer “optional knowledge” for X++ developers.

Learning Git is not about tools.
It’s about working in a way that matches where D365 F&O is heading.

And the sooner you start, the smoother that journey will be.

Good Git Learning References for X++ Developers

If you’re new to Git, the biggest mistake is trying to learn everything at once.
You don’t need that.

Start with practical, beginner-friendly resources that focus on day-to-day usage.

---

1. Microsoft Learn – Git with Azure DevOps (Best Starting Point)

Why this is great for D365 F&O developers:

• Microsoft-authored
• Uses Azure DevOps (same ecosystem as D365 F&O)
• Explains Git in simple, structured steps

Recommended modules:

• Introduction to Git
• Store your code in Azure Repos
• Collaborate with pull requests

https://learn.microsoft.com/azure/devops/repos/git/

---

2. Git Official Documentation (Use as Reference, Not First Read)

This is the source of truth, but it can feel heavy at first.

Use it when:

• You want to understand what a command actually does
• You are stuck and need clarity

https://git-scm.com/docs

Tip: Bookmark it. Don’t try to read it end-to-end.

---

3. GitHub Git Handbook (Very Beginner Friendly)

Even if you don’t use GitHub daily, this guide explains Git concepts clearly.

Good for:

• Understanding commits, branches, and merges
• Visualising how Git works

https://guides.github.com/introduction/git-handbook/

---

4. “Learn Git Branching” – Visual & Interactive

This is one of the best learning tools if branching feels confusing.

Why it works:

• Visual
• Interactive
• No setup required

https://learngitbranching.js.org/

Spend 30–45 minutes here and branching will suddenly make sense.

---

5. Azure DevOps Git + Pull Requests (Must-Have for ALM)

Since most D365 F&O projects use Azure DevOps, learning Git with PRs is critical.

Focus on:

• Creating pull requests
• Reviewing code
• Understanding branch policies

https://learn.microsoft.com/azure/devops/repos/git/pull-requests

---

6. Simple Git Cheat Sheet (Quick Confidence Builder)

Perfect for:

• Daily reference
• Translating TFVC habits to Git commands

https://education.github.com/git-cheat-sheet-education.pdf

Print it or keep it on your second screen initially.

---

Suggested Learning Path (No Overwhelm)

If you want a simple 5-step plan, follow this order:

1. Understand basic Git concepts (repo, commit, branch)
2. Learn clone, commit, push, and pull
3. Practice feature branches
4. Learn pull requests in Azure DevOps
5. Slowly explore merge conflicts and rebasing

---

Final Tip for X++ Developers

You don’t learn Git by reading alone.
You learn it by using it a little every day.

Make mistakes.
Undo them.
Learn from them.

That’s exactly how Git was designed to be used.

And once it clicks, you’ll wonder how you ever worked without it.