If you’ve worked in Dynamics 365 Finance & Operations long enough, you’ve probably seen it: TFVC merging goes from “fine” to “painful” the moment the pressure is on.

And the truth is simple. Most TFVC merge mistakes aren’t caused by lack of skill. They’re caused by a process that is too permissive, too manual, and too repetitive to stay reliable at scale.

Visual Studio’s TFVC merge UI is powerful… and that’s part of the problem

Visual Studio’s TFVC merge interface gives you a lot of freedom, and that freedom is exactly what makes it risky. The tool will let you merge almost anything into almost anything, and it doesn’t force you to slow down and confirm intent. When everything is calm, that flexibility feels convenient. When you’re in the middle of a release, it becomes a liability.

A perfect example is the reverse merge. You meant to merge DEV into TEST or UAT, but you accidentally merge TEST or UAT back into DEV. I’ve seen this happen in real projects, and it’s not because the person doing it was incompetent. It happens because the interface makes it possible, and under pressure the brain goes into autopilot.

When a tool allows dangerous actions without strong guardrails, eventually somebody will take the wrong path by accident.

TFVC merging is repetitive, and repetition creates risk

TFVC merging isn’t one action. It’s a sequence. You identify the changesets you need, perform the merge, deal with conflicts when they appear, verify what changed, communicate what moved, and then check in. On top of all that, you have to keep discipline around “get latest before check in”, which is the TFVC equivalent of “pull before push”.

None of these steps are technically difficult. The problem is that they are repetitive. Repetition creates fatigue, and fatigue creates mistakes. People don’t usually fail on merge number one. They fail on merge number fifty, when they’ve been clicking through the same dialogs for an hour and they’re trying to finish before the next emergency pops up.

At that point you’re not “merging code” anymore. You’re running a manual operational process where missing one step can waste hours.

Scaling issues: merging 5 changesets is not the same as merging 50

Merging a handful of changesets is manageable. Merging dozens is where TFVC starts showing its scaling limits. The time cost explodes, the mental load goes up, and the probability of missing something increases. It becomes easy to lose track of what you already merged, what’s still pending, and what was included in the last promotion.

And even when everything goes “right”, you still end up spending a ridiculous amount of time doing repetitive work that adds no value other than slowly pushing code forward.

When merges are centralized, it becomes overwhelming fast

Some teams distribute promotions and merges across developers. But many D365F&O teams don’t. In a lot of real projects, merges fall on one person: the lead dev, the release owner, or the person everyone trusts to “not break it”.

That’s when the scaling problem becomes a people problem. Not because the person can’t handle it, but because the workflow becomes too heavy to do safely and consistently while also doing everything else a lead is responsible for. Centralized merging becomes a bottleneck, and it creates a single point of failure during every release window.

Why this matters in D365F&O specifically

D365F&O promotions are rarely “just code”. They usually involve multiple models, cross-team dependencies, timelines that the business cares about, and a very low tolerance for mistakes. When TFVC merges go wrong, the impact is immediate. It costs time, it damages confidence, and it turns releases into chaos.

This is why TFVC merging through Visual Studio feels acceptable in small volumes, but fragile once the workload increases. The process doesn’t scale smoothly, and it doesn’t protect you when things are moving fast.

How I personally solved this

After running into these issues repeatedly in real D365F&O environments, I decided to solve it properly. That’s why I created Cordova, a lightweight DevOps companion tool for D365F&O teams using TFVC, built specifically to make large merge batches safer, faster, and less error-prone.

This isn’t theoretical for me. I’ve used Cordova for years in my own day-to-day work to do merges and, just as importantly, to communicate clearly what got promoted, when it was promoted, and why.

If you’re dealing with TFVC merge fatigue, repetitive promotion steps, or scaling problems as changesets pile up, feel free to check it out. Cordova TFVC Community Edition (Single User) is free to use. Product page and download link: Click here.