An Advanced Dungeons & Dynamics 365 session. Episode 12 of 14.

Previously on: Episode 11, Character Sheets, Denise’s caution turned out to be expertise nobody had asked about, and Vex offered to dig into the field she’d learned to distrust, the one that was wrong about one time in six.

Two weeks to go live. Everything on the ledger side finally looks green. This episode, that calm gets interrupted by something nobody was even looking for.


The Session

Vex: (deep in the code) Found something. There’s an override on tax calc. It only fires on international orders.

Thorne: Since when?

Vex: Git blame says two years ago. Author’s account is deactivated.

Sable: Do we know why it exists?

Vex: No comments. No ticket reference. Just a hardcoded exception for a specific country tax code.

Ai. Cassiopeia: I searched historical support tickets. There is a closed ticket from that period referencing an audit finding. No resolution notes attached.

Marge: Two weeks to go live and we’ve found a silent override to statutory tax logic with no documentation and no author.

Thorne: We can’t ship blind on tax. Not this close to the finish line, not this category.

Vex: I can reverse engineer what it’s compensating for. Give me two days.

Vex disappears into the code for the better part of the next two days, surfacing occasionally for coffee and increasingly specific questions.

Vex: (day one, afternoon) This override is doing something very deliberate. It’s not sloppy code. Whoever wrote this understood the tax engine at a level most consultants never bother to reach.

Sable: That’s not reassuring. That’s more unsettling.

Vex: (day two, morning) I think I found the audit finding it was responding to. There’s a gap between how the platform’s native tax engine handled a specific cross border scenario two years ago, and how the actual tax authority required it to be handled. Someone found that gap during an audit, panicked, and built this override to close it fast.

Thorne: Did it work?

Vex: (pulling up a comparison, going quiet) I need another hour before I answer that honestly.

Two days later, Vex has the answer, and it’s not what anyone expected.

Vex: The platform fixed the underlying bug in an update about eighteen months ago. This override is still running. On top of the fix.


The patch that outlived the problem it solved

An override built under audit pressure, with no documentation and a deactivated author, is exactly the kind of artifact that should terrify anyone doing a go live readiness review. But the actual failure here isn’t the override’s existence. Overrides built in a hurry, in response to a real and urgent finding, happen constantly, and they’re often the right call in the moment. The failure is that nobody built in a mechanism to revisit it once the underlying platform caught up.

That’s a subtly different problem than most of what the party has found so far. The shadow ledger, the TEMP dimension, the silent integration, all of those were things nobody built correctly the first time. This one was built correctly, for the moment it was built in, by someone who clearly understood the tax engine well enough to solve a genuinely hard problem under real pressure. The failure happened later, quietly, when the platform vendor shipped a fix and nothing in Contoso’s environment ever checked whether the original workaround was still needed.

This is the maintenance half of technical debt that almost nobody plans for. Everyone budgets for building the workaround. Almost nobody budgets for the moment, months or years later, when the reason for the workaround quietly disappears and the workaround itself doesn’t. A patch with no expiration date and no owner just keeps running, doing whatever it was built to do, whether or not that’s still the right thing to do.


What happens next

The platform fix and the old override are now both active, which means international tax has likely been calculated twice for a very long time. The party has two weeks to go live and a discovery that reaches back much further than two weeks, into territory that’s going to need more than an engineering fix.

Next episode: Episode 13, The Audit Trail (coming soon)


If your environment has a workaround built in response to a problem that might already be solved somewhere upstream, this episode is worth sitting with. Gamifying the Enterprise: Game Mechanics for Continuous Proficiency is available now on Amazon: https://www.amazon.com/dp/B0GY3VWLVX

And if you want a framework built around giving every workaround an owner and an expiration date, start here: adnd365.com/start

There used to be a saying in the business world: everything can be done with time and Excel. Give a competent analyst enough hours and a blank spreadsheet, and there was no forecast, no reconciliation, no reporting problem that couldn’t eventually be solved. Excel wasn’t fast. It wasn’t elegant. But it was infinitely general purpose, and it always did exactly what you told it to do, cell by cell, every single time.

The saying is starting to change. People are now saying everything can be done with time and tokens.

It’s worth taking that seriously, because it’s not just a joke about AI hype. Something real shifted underneath it.

What Excel actually required

The old saying hid a dependency that everyone quietly understood. Excel could do anything, but only if a human already knew what “anything” looked like. Someone had to understand the business problem, decide what the model should compute, structure the formulas, and catch the errors when a dragged cell reference pointed at the wrong row. The tool was general. The thinking was not automated at all. Time, in that saying, mostly meant the time it took a skilled person to build and rebuild the model until it matched reality.

That is why “time and Excel” was a saying about human effort as much as it was about software. The spreadsheet was a canvas. The intelligence was still entirely yours.

What tokens change

A large language model flips part of that arrangement. You can now describe a vague, half formed problem in plain language and get something usable back without doing the structural thinking first. The model proposes the categories, drafts the formulas, writes the summary, or builds the first pass at a plan. Tokens, in the new saying, stand in for both the words you feed the model and the compute it burns iterating toward an answer.

This is a genuine capability shift, not just a rebrand of the old joke. With Excel, the bottleneck was almost always model construction. With a language model, the bottleneck moves toward specification and verification. You spend less time building the machine and more time describing what you want and checking whether what came back is actually right.

That is a real change in where human effort goes. It is not a small one.

Where the analogy breaks

It would be tidy to say tokens simply replaced Excel, but that’s not quite what’s happening, and the difference matters more the higher the stakes get.

Excel’s defining property was determinism. A formula produces the same output from the same inputs every time, and you can trace exactly why. That traceability is not a nice to have in finance, operations, or compliance work. It is the entire point. An auditor does not want to hear that the number is “probably right.” They want to see the formula.

Tokens do not offer that guarantee. A language model produces a plausible answer, and plausible is doing a lot of work in that sentence. Ask the same question twice and you may get two different, both reasonable sounding, results. For a first draft, a brainstorm, or a rough model, that is a feature. For a general ledger reconciliation, it is a liability.

So the honest version of the new saying is not that tokens replaced Excel. It is that tokens increasingly generate the Excel. The model drafts the formula, proposes the pivot, writes the first pass at the model, and a deterministic engine, spreadsheet or database or ERP calculation, still does the actual execution. The two are stacking, not swapping.

The bottleneck didn’t disappear, it moved

The old saying implied that with enough time, Excel could solve anything, and the effort lived in building the model correctly. The new saying implies that with enough tokens, a model can solve anything, and the effort lives somewhere else now: in asking the question well and in checking the answer carefully.

That is arguably a harder skill to teach than spreadsheet formulas ever were. A bad formula usually breaks visibly. A bad prompt often produces something that looks complete and confident and is wrong in a way that takes real domain knowledge to catch. The scarce resource used to be knowing how to build the model. Increasingly, the scarce resource is knowing enough about the problem to tell a good answer from a good sounding one.

Why this should sound familiar

Anyone who has sat through an ERP vendor demo has already seen a preview of this exact pattern. The demo always ends the same way: with the confident implication that the software understands your business and can just handle it, no configuration debt, no data cleanup, no edge cases. Excel never made that promise. It never pretended to understand your problem. It just calculated exactly what you told it to.

Tokens, by contrast, come wrapped in the same confident tone as the demo. The output reads fluently. It sounds like understanding. Whether it actually reflects your business, your chart of accounts, your specific edge case, is a separate question that the fluency does nothing to answer.

That is the real risk in the new saying, and it has nothing to do with the technology’s capability. It is the same trap the old vendor demos set: mistaking a confident answer for a correct one. Excel forced you to see your assumptions in the formula bar. Tokens can hide them in a paragraph that sounds like it already checked.

The updated version

Everything can still be done with time and Excel. That has not stopped being true. What’s changed is that tokens now do a lot of the early modeling work that used to eat the time. The saying isn’t wrong to update. It’s just missing a clause.

Everything can be done with time and tokens, as long as someone still knows enough to check the work.

Cause of death: confidence borrowed from someone who was never actually going to be there.


Ten minutes into the meeting, or sometimes ten minutes before the end of it, a calendar notification pulls someone senior into the call. A VP, sometimes higher. They say a few warm, general things about strategic partnership and long-term vision, take one or two softball questions, and leave for their next meeting. The room’s posture changes almost immediately. If someone at that level is personally invested enough to show up, even briefly, this must really matter to the vendor. The deal, whatever doubts existed five minutes earlier, now feels more serious.

Nobody asks what “personally invested” is actually going to mean six months from now, when the invoices are contested, the timeline slips, or the implementation team needs an escalation path that goes higher than the account manager. That’s the autopsy. The executive’s presence proved that a calendar invite got accepted. It proved nothing about what happens after the meeting ends.

What actually happened

An executive sponsor cameo is a highly efficient transfer of credibility from a person to a deal, and the transfer costs the vendor almost nothing to make. Ten minutes of a VP’s time is genuinely cheap relative to the deal size being discussed, and the effect on the room is entirely disproportionate to that cost, because the audience reads presence as commitment. It rarely is. In most organizations selling anything of this size, senior leaders make these appearances routinely, across many simultaneous deals, as a normal part of their job, not as a signal that this particular account has been elevated to a special tier of personal attention.

The deeper issue is that the thing actually being evaluated, whether the vendor will show up when the implementation gets hard, is not a property of any one person’s goodwill. It’s a property of organizational structures: escalation paths, contractual service levels, account team continuity, whether the people doing the actual implementation work have the authority and resources to fix problems without waiting on approval from someone three levels up. None of that gets tested by a cameo. A cameo tests whether an executive’s assistant could find a ten-minute gap in a calendar.

There’s also a durability problem the cameo doesn’t address. The VP who dropped in with warm words about the partnership may be gone, reorganized, or reassigned to a different portfolio before the implementation is even a third of the way done, which happens routinely in any organization above a certain size. The relationship the room felt reassured by was never actually contracted. It was a mood, generated in a room, that has no mechanism for surviving contact with an org chart six months later.

Why it works on smart people

Status carries information in most human interactions, and that heuristic is usually reasonable: when someone senior spends scarce time on something, it often does signal real priority. The problem is that the heuristic breaks down specifically in situations, like enterprise sales, where the cost of the senior person’s time has been deliberately minimized to make the signal cheap to send. A genuine ten-minute cameo and a fully commissioned, resourced executive sponsorship look identical for the ten minutes you can observe them. They diverge entirely in the six months you can’t.

There’s also a reciprocity dynamic at play. A senior person taking time to personally reassure you creates a mild social obligation to receive that reassurance graciously, not to interrogate it. Asking a VP who just delivered warm remarks about partnership to specify exactly what escalation authority they’re personally committing to feels confrontational in a way that asking the account manager the same question doesn’t, so the question quietly goes unasked at exactly the moment it would have been most useful to ask it.

The actual damage

This is the one that surfaces the first time something actually goes wrong during implementation and the buyer tries to use the relationship they thought they’d built. The champion emails the VP directly, the way the cameo implicitly invited them to, and gets a response from an assistant, or a redirect back to the account team, or silence, because the VP’s actual involvement was never structured to include personal escalation on operational issues. The confidence the room felt in that meeting has no contractual or organizational form. It was real in the room and evaporated the moment it needed to be load-bearing.

The buyer is left in a worse position than if the executive had never appeared at all, because the cameo specifically substituted for asking the harder, more useful questions about actual escalation paths and account team continuity, the answers to which would have held up regardless of who was in what job six months later.

The fix, if you’re the one presenting, or the one buying

If you’re presenting, don’t let the cameo stand in for structure. If an executive is genuinely sponsoring the account, say specifically what that means: a defined escalation path with their name attached, a commitment to a quarterly check-in that’s on a calendar rather than implied, actual authority to authorize resources if the implementation hits trouble. If none of that exists, the honest version of the cameo is shorter and less dramatic, a courtesy visit rather than a commitment, and it should be presented as exactly that.

If you’re buying, ask the question the warm remarks were designed to make feel unnecessary: what happens, specifically, and who do we call, when this goes wrong. The answer that matters is a name and a process that survives a reorg. The ten minutes in the room, however sincere, was never that.


Genuine organizational attention rarely looks like a scheduled cameo. In The Penguins Knew Before Your Steering Committee Did, the character who actually notices the iceberg melting and does something about it is an unremarkable penguin, not the colony’s formal leadership showing up to reassure everyone for ten minutes. The steering committee structure is the cameo. The attention that actually matters usually comes from somewhere quieter.

An Advanced Dungeons & Dynamics 365 session. Episode 11 of 14.

Previously on: Episode 10, The Wayfinder’s Gap, the party discovered that Contoso’s ninety four percent training completion rate measured attendance, not competence, and that six of eight power users couldn’t complete a basic order to cash cycle without help, three weeks before go live.

A readiness assessment tells you who’s struggling. It doesn’t always tell you why. This episode, the party finds out that the worst score in the room might be measuring exactly the wrong thing.


The Session

GM: The party builds character sheets for each of the eight power users: role, current XP, gaps, and a coordinate on the Wayfinder’s Network showing where they stand versus where they need to be.

Sable: Denise scored lowest on the readiness test. Struggled with three of five scenarios.

Ai. Cassiopeia: I pulled her transaction history for context, as requested. She has the lowest error rate of any user in AP. By a wide margin.

Marge: How does someone with the lowest error rate score lowest on a scenario test?

Vex: Because the test measures speed and screen navigation. It doesn’t measure judgment.

Thorne: She’s not undertrained. She’s over cautious, because she’s the one who’s been quietly catching everyone else’s mistakes and never gets asked how she knew to check.

Denise: (overhearing from the doorway) Nobody asked, so I didn’t say anything.

The room turns. Denise steps in, arms crossed, more defensive than embarrassed.

Marge: Denise, walk us through why you struggled on the partial shipment scenario.

Denise: I didn’t struggle. I stopped. There’s a field on that screen that’s populated wrong about one time in six, and if you don’t catch it before you post, it throws off freight allocation two steps downstream. The test wanted me to move fast. I’ve learned not to move fast on that screen.

Sable: (quietly) That’s not a training gap. That’s institutional knowledge nobody documented.

Denise: I mentioned it once, in month two. It didn’t go anywhere, so I stopped mentioning things.

Ai. Cassiopeia: I recommend her proficiency path include a mentor tier, not a remedial tier.

Vex: Denise, that field, the one that’s wrong one time in six. What’s actually causing it?

Denise: (pausing, surprised to be asked) I always assumed it was a timing issue with the freight feed. Nobody ever asked me to look closer.

Vex: I have some time this afternoon. Want to look closer together?

Denise: (a beat, then) Yeah. Actually, yeah.

The party rebuilds the plan. Denise goes from “at risk” to “quiet expert” in one conversation, and the readiness map shifts under everyone’s feet.


What a readiness score actually measures

Every assessment measures something specific, and it’s worth asking exactly what before you trust the score it produces. Contoso’s readiness test measured speed and screen navigation under time pressure. That’s a reasonable thing to measure, but it’s not the same thing as competence, and Denise is the proof. Her caution wasn’t a skill gap. It was a defensible, earned response to a system that had already burned her once, and the test penalized the exact behavior that was protecting the business every single month.

The more troubling detail isn’t the test design, though. It’s that Denise had already raised this issue once, in month two, and it went nowhere. That’s the part that should sting a little, because it means the information the party needed was sitting in the building the entire time, just not in a form anyone had built a channel to receive. Nobody was hiding it from her. There was simply no mechanism that treated a frontline observation from someone without formal standing as worth following up on.

This is the actual argument for a proficiency system that includes mentor tiers alongside remedial ones. A readiness score that only sorts people into “needs help” and “doesn’t need help” throws away the most valuable signal in the data: the person whose caution is actually expertise wearing an unflattering score. Vex asking Denise to look closer together, instead of just logging her workaround and moving on, is the moment this episode is actually about. Competence that never gets asked a follow up question stays invisible indefinitely, no matter how many times the person tries to mention it.


What happens next

Denise’s insight reshapes the readiness map and buys the team a genuine mentor for the seven days that remain. But rebuilding proficiency around real expertise instead of raw scores means someone finally has to go back into the system Denise flagged, and what Vex finds when he looks closer is worse than a timing issue with the freight feed.

Next episode: Episode 12, The Customization Nobody Remembers (coming soon)


If someone on your team has mentioned a workaround once and then quietly stopped bringing it up, this episode is for them. Gamifying the Enterprise: Game Mechanics for Continuous Proficiency is available now on Amazon: https://www.amazon.com/dp/B0GY3VWLVX

And if you want a system built to actually catch signals like Denise’s instead of losing them in a scorecard, start here: adnd365.com/start

I have heard rumours that some companies are starting to vibe code their own ERP systems. Is this the start of the decline of standardized ERP systems, and the start of company specific Business Operating Systems? If every business had its own OS, and an agentic framework, why is there any need to have standardized ERP systems?

It is a fair question, and one worth taking seriously instead of dismissing on reflex. But after digging into what is actually happening in the market, I do not think ERP is dying. I think something more interesting and more useful is happening at its edges.

What Companies Are Actually Vibe Coding

The companies experimenting with AI generated business software right now are almost entirely building at the periphery of ERP, not in its core. A Copilot Cowork style agent that reconciles a report. A custom approval workflow. A data cleanup script. A bolt on dashboard that nobody wanted to wait six weeks for IT to build. Very few organizations are vibe coding their general ledger, their costing engine, or their multi entity intercompany eliminations, and there is a good reason for that.

There is a real gap between “AI helped me build software” and “AI helped me build enterprise grade, auditable, multi user, transactionally consistent financial software.” That gap is where most of the current enthusiasm quietly runs out of road. One recent piece on the risks of vibe coding put it plainly: the danger is not that these tools fail to work. The software appears to work right up until the business reaches a level of complexity that exposes what was never built in the first place. Security, monitoring, compliance, and disaster recovery do not show up in a demo. They show up eighteen months later when something breaks and there is no vendor to call.

We Have Been Here Before

There is also a useful historical echo worth remembering. Standardized platforms like SAP, Oracle, PeopleSoft, and later NetSuite and Salesforce did not emerge in a vacuum. They emerged because “build your own” had already been tried extensively in the eighties and nineties, and the industry collectively decided that a professionally maintained, continuously improved, shared system was the better bargain. One system, supported by a vendor with thousands of customers absorbing the cost of getting tax law and audit controls right, beat a thousand bespoke systems each carrying that burden alone.

Vibe coding does not remove the reasons that decision was made three decades ago. It just lowers the upfront cost of relearning them the hard way.

Two Layers That Want Different Economics

The question of “why standardize if every business can have its own OS” collapses two layers of the business that actually want very different things.

The first layer is the system of record. This is the ledger, inventory, costing, tax, and consolidation logic. This layer wants low variance, not customization. Its value comes from being provably correct under audit, from producing the same math every quarter regardless of who is running the company, and from a vendor carrying the liability of getting VAT rules or SOX controls right across thousands of customers instead of one company carrying that risk alone. Agentic capability does not change the incentive to pool that risk and cost across an ecosystem. If anything it raises the stakes, because an agent posting a bad journal entry at two in the morning with no human review is a considerably scarier proposition than a person doing it.

The second layer is orchestration. This is how a specific company actually gets things done around that system of record. This is exactly where variance is valuable, and exactly where agentic frameworks and vibe coding are already winning, because it is low blast radius, fast changing, and does not need to survive a financial audit on its own merits.

The Composable Core, Not the Bespoke Empire

So the more likely outcome is not that every business ends up building its own ERP from scratch. It is something closer to a composable core: a thin, standardized, vendor maintained transactional spine, surrounded by a thick, company specific, largely agent authored layer of workflow, automation, and decision logic that talks to that spine through APIs. This is not a new architecture invented for the agentic era. It is basically the direction that platforms like Dynamics 365 Finance and Operations were already heading, with data entities and business events designed precisely so that logic could live outside the core without touching it.

The Business Operating System that gets discussed in these conversations is real. But it gets built on top of standardized ERP, not instead of it, because nobody actually wants to own tax engine liability, and no CFO wants to explain to auditors that the general ledger was vibe coded last quarter.

Where the Real Disruption Sits

If I had to point at where this trend genuinely threatens the standard ERP model, it would be three places.

The mid market and small business segment, where compliance and audit stakes are lower and the cost of a full ERP license and implementation is disproportionate to the size of the operation. This is where skipping a Tier 2 ERP entirely in favour of an agentic build of the operations layer is most economically rational.

Verticals with no good off the shelf fit, where companies already customize ERP into something barely recognizable compared to the base product. Vibe coding just makes that customization faster and cheaper. It is not a fundamentally new behaviour, it is an acceleration of an old one.

And the vendors themselves, who will not sit still and watch this happen. Expect Microsoft, SAP, and Oracle to lean hard into a “we are the trusted core, bring your own agents to the edges” positioning rather than fight the trend directly. Given where Copilot and Cowork are already headed inside the Microsoft ecosystem, this is not speculation. It is already the direction of travel.

The Verdict

Vibe coding is not the death of standardized ERP. It is the arrival of a cheap, fast way to build the layer of the business that ERP vendors were never well suited to build in the first place. The ledger stays boring, standardized, and vendor owned, because boring is exactly what you want from something an auditor has to sign off on. Everything wrapped around it just got a lot more interesting.

John Kotter wrote Our Iceberg Is Melting as a fable for people who already knew his eight step change model and needed a way to explain it to everyone else without putting them to sleep. A colony of Antarctic penguins lives on an iceberg. One of them, an unremarkable penguin named Fred, notices the iceberg is riddled with cracks and will not survive the winter. Nobody wants to hear it. The leadership council is comfortable. The colony has always lived on this iceberg. Fred is not important enough to be believed.

The book is aimed at children and executives in roughly equal measure, which tells you something about how leaders actually respond to bad news about the platform they built their careers on.

I have spent enough years around D365 F&O implementations to recognize every penguin in that story. Most ERP failures are not technical failures. The system usually works. What fails is the eight step sequence Kotter is illustrating, and it fails in the same order every time.

Step One: Someone Has to Notice the Cracks

Fred does not manufacture urgency. He finds it, through unglamorous observation, and then has to fight to get anyone to look at what he found. In an ERP program this is usually the business analyst three levels down who has actually mapped the current state process and knows the general ledger reconciliation takes eleven days by hand. Nobody asked her opinion because the steering committee already decided the go-live date.

Urgency that is manufactured by a consultant in a kickoff deck does not survive contact with month four. Urgency that comes from someone inside the organization who found the actual crack tends to.

Step Two through Four: The Guiding Team Is Not the Org Chart

Louis, the head penguin, does not solve the problem alone, and he does not delegate it to a committee chosen by rank. He assembles a mixed group that includes NoNo the professional skeptic, because a guiding coalition that only contains believers cannot survive contact with the rest of the colony. NoNo’s objections get answered in advance instead of ambushing the project in month six.

I have sat in enough steering committees to know most of them are built from an org chart, not from who actually has credibility on the floor. A finance director with veto power and zero trust from the warehouse team is not a guiding coalition. He is a bottleneck with a title.

Steps Five through Seven: Short Wins or No Buy In

The colony does not wait for the whole migration plan before it sees a win. The penguins send scouts, they find a new iceberg, and they celebrate finding it long before anyone has actually moved. This is the part of the model most ERP programs skip entirely. Everything gets held for the big bang go-live, and by the time it arrives the organization has spent a year hearing about a future state it has never once been allowed to touch.

Every fit-gap workshop I have run that included a working demo of one solved process, even a small one, bought more goodwill than any status report ever has. People do not commit to a vision. They commit to evidence the vision is real.

Step Eight: The New Iceberg Has to Become Normal

The fable ends with the colony living on the new iceberg as though they had always lived there, and this is the step almost nobody in ERP world budgets for. Go-live is treated as the finish line. It is closer to the halfway mark. The old habits, the shadow spreadsheets, the workaround someone built in Excel because the new system was inconvenient in week two, all of that quietly recolonizes the organization unless someone is watching for it.

I have seen systems go live successfully and then watch the business slide back into its old processes within a fiscal quarter because nobody treated adoption as an ongoing job. The iceberg was new. The habits were not.

Why the Fable Works Better Than the Framework

Kotter could have written the eight steps as a slide deck. He wrote a story instead, because a story lets you see NoNo’s objection land and get resolved instead of reading a bullet that says manage resistance. It lets you watch Louis choose the guiding team instead of reading a bullet that says build a coalition. The mechanism becomes visible instead of asserted.

That is the actual argument for using fables and analogies in change management work generally, ERP or otherwise. An eight step framework tells people what to do. A story shows them what it looks like when someone does not do it, which is usually the more persuasive lesson.

If your organization is mid migration and something feels off, it is worth asking which penguin is missing. Often it is not a step in the model that got skipped. It is a specific person, the one who noticed the crack early and was not believed.

Our Iceberg Is Melting by John Kotter and Holger Rathgeber: https://www.amazon.com/Our-Iceberg-Melting-Succeeding-Conditions/dp/0399563911

Cause of death: the entire session proved the system worked, and none of it proved anyone would use it.


Ninety minutes of demo. Every module clicked through, every workflow shown, every objection about functionality answered on the spot. Then, in the last five minutes, someone asks about training and adoption, and the presenter says something reassuring and short: “the interface is intuitive, users pick it up quickly,” maybe gestures at a slide with a generic icon of people around a laptop, and the meeting ends on schedule.

Nothing in those ninety minutes tested the only variable that determines whether an ERP implementation actually pays off: whether the several hundred people who currently do their jobs a certain way will actually do them a different way starting on a specific Monday morning. That variable got five minutes and a slide. Everything else got ninety.

What actually happened

A demo is, by construction, a test of the system in isolation. It shows what the software can do when operated by someone who already knows exactly which buttons to press, in exactly the right order, with no muscle memory pulling them back toward the old way of doing things. That’s a test of the product. It says almost nothing about the much harder problem sitting underneath every ERP rollout, which is that the system doesn’t fail because it can’t do the work. It fails, when it fails, because the people who were supposed to start using it on day one didn’t, or did so inconsistently, or found a workaround that quietly recreated the old process inside the new tool.

The demo cannot show this risk because the risk doesn’t live in the software. It lives in a warehouse supervisor who has run the same process for eleven years and has a system that works well enough for them, a controller who doesn’t trust the new close process until they’ve watched it succeed three months running, a data entry team that will, absent enforcement, keep using the spreadsheet they built in 2019 because it’s faster for them personally even if it creates downstream problems for everyone else. None of that shows up in a screen share. All of it shows up in the first ninety days of production.

Why it works on smart people

Functionality is legible in a way that adoption risk isn’t. You can watch a screen and evaluate, with reasonable confidence, whether a feature does what it claims to do. You cannot watch a screen and evaluate whether the accounts payable team, specifically, at your company, specifically, will actually change how they process an invoice exception, because that isn’t a property of the software being demonstrated. It’s a property of an organization that isn’t in the room.

Because functionality is the thing that’s easy to evaluate in real time, it naturally consumes the meeting. Evaluators default to spending their scrutiny where scrutiny is possible to apply, and adoption risk, being diffuse, organizational, and only observable months later, gets the leftover attention at the end of the agenda, not because anyone decided it mattered less, but because there was no way to spend ninety minutes evaluating it the way there was for the features.

There’s also a comforting assumption doing a lot of quiet work: that a system good enough to buy will be a system people are willing to use. That assumption is often wrong in a specific, predictable direction. The features that make a system good for the business, tighter controls, more required fields, more visible audit trails, are frequently the exact features that make individual users’ jobs feel harder in the short term, which is precisely the friction that produces workarounds and shadow processes.

The actual damage

This is the failure mode that shows up as an implementation that technically went live and never actually delivered its business case. The system works. The training happened, in the generic sense that sessions were held and attendance was tracked. And six months later, half the intended users are still keeping a parallel spreadsheet, a workaround team has formed around one specific process nobody bothered to redesign for the new tool, and the data quality problems the new system was supposed to fix are still there, because garbage still goes in whenever someone routes around the system instead of through it.

Nobody can point to a single moment this failed. It failed gradually, in a thousand small individual decisions to keep doing things the old way, none of which showed up as a defect, an error, or a support ticket, because from the system’s point of view nothing went wrong. The people just didn’t come.

The fix, if you’re the one presenting, or the one buying

Treat adoption as a first-class item in the evaluation, not a closing slide. Ask the vendor, specifically, what happens to the specific roles in your organization who will feel the most friction from the new process, not the roles who benefit most. Ask what the actual training plan looks like beyond a generic session count, and who owns reinforcement after go-live, when the temptation to slide back into the old process is highest. If you’re the one presenting, bring a real adoption story, with a real friction point that was anticipated and addressed, instead of a slide with a stock photo and the word “intuitive.”

A system that works and a system that gets used are not the same claim, and only one of them was tested in that room.


This is exactly the gap I dug into in Gamification of ERP: Turning Drudgery into Dopamine. Points and badges won’t fix a bad rollout, but the underlying problem, that a system’s success depends on individual motivation, not just individual capability, is precisely the variable this autopsy argues nobody tests before go-live.

An Advanced Dungeons & Dynamics 365 session. Episode 10 of 14.

Previously on: Episode 9, The Real Cost, the party proved that Feld’s sixty percent rebate automation cut hadn’t saved money at all, it had just moved the cost onto Oskar’s calendar where nobody was tracking it. Feld approved the fix on the spot.

Every fire the party has put out so far has lived in the system, in the ledger, in the integrations, in the chart of accounts. This episode, the fire finally shows up in the people, and it’s the kind of problem a clean go live can’t fix on its own.


The Session

GM: Marge runs a readiness assessment. Eight power users, one basic scenario: process an order, ship it, invoice it.

Marge: Two pass clean. Six need help at some point in the process.

Thorne: Same six who sat through training in month one?

Marge: Same six.

Ai. Cassiopeia: Training completion was recorded at ninety four percent. Retention, apparently, was not measured.

Sable: That’s the forgetting curve. Training happened five months before go live. Nobody built in reinforcement.

Vex: So we trained people once, checked a box, and assumed the knowledge would just stay?

Marge: It’s the single most common failure point I’ve seen. Bigger than any integration bug.

Thorne: Three weeks isn’t enough time to retrain from scratch.

Marge: It’s enough time to build a proficiency system instead of a training event. Short, repeated, gamified reinforcement. Not a redo of month one.

Vex: (pulling up the training completion report) Look at this. Ninety four percent completion, and the completion metric is literally just “did they click through all the slides.” There’s no assessment attached at all.

Sable: So we’ve been measuring attendance and calling it competence.

Ai. Cassiopeia: That is an accurate summary of the metric’s actual scope, yes.

Marge: Which means we don’t actually know what any of these eight people know right now. We only know what they sat through once, five months ago.

Thorne: (grimly) We’re not three weeks behind on training. We’re flying blind on it, and we just found that out three weeks before go live.

Sable pulls out a coordinate map of every process the eight users need to own, the beginning of what the party will start calling the Wayfinder’s Network.


The metric that was never measuring the thing

Ninety four percent completion sounds like a success metric right up until you ask what it’s actually counting. In this case, it was counting attendance, whether someone clicked through every slide, and nothing about whether the material stuck, or whether the person could apply it under real conditions five months later. That’s not a rare mistake. It’s the default mistake, because attendance is easy to measure and competence is hard to measure, and organizations tend to report the metric they have rather than the metric they need.

The forgetting curve isn’t a new idea. Psychologists have understood for over a century that knowledge decays predictably after a single exposure unless it’s reinforced. What’s notable here isn’t that Contoso’s training decayed, that was always going to happen. What’s notable is that nobody built anything to catch the decay before go live, because the completion dashboard said ninety four percent and ninety four percent looked like done.

This is the gap a lot of change management plans never close: the difference between “we delivered training” and “we know what people currently know.” The first is a project milestone. The second is a fact about the state of the organization, and it’s the only one of the two that actually predicts what happens on a Monday morning cutover. Marge’s instinct, build a proficiency system instead of trying to cram a redo of month one into three weeks, is the right move precisely because it treats competence as something you maintain continuously, not something you deliver once and check off.


What happens next

The party now has three weeks to build what should have existed from month one: a system that actually measures and reinforces what these eight people know, rather than what they once sat through. But building the character sheets for each power user surfaces something the readiness assessment completely missed, the person who scored worst on the test might actually be the sharpest set of eyes in the building.

Next episode: Episode 11, Character Sheets (coming soon)


The forgetting curve is the whole reason Gamifying the Enterprise: Game Mechanics for Continuous Proficiency exists. If this episode felt familiar, that’s not a coincidence, it’s the book’s founding problem, worked out here in real time. Available now on Amazon: https://www.amazon.com/dp/B0GY3VWLVX

And if you want the actual framework behind building a proficiency system instead of a training event, start here: adnd365.com/start

An Advanced Dungeons & Dynamics 365 session. Episode 9 of 14.

Previously on: Episode 8, What Feld Knew, Feld admitted he cut sixty percent of the original rebate automation budget eighteen months ago, and let two failed go live attempts pass without ever mentioning it. He asked the party what it would actually cost to do it right this time.

Every project has a number that never got calculated the first time around, because calculating it honestly would have made an uncomfortable decision harder to justify. This episode, the party finally does the math nobody did eighteen months ago.


The Session

Sable: I priced it out. Fully automated rebate accrual, configured correctly against the current contract terms. Here’s the effort estimate.

Feld: And the eighteen months of manual work Oskar’s been doing?

Ai. Cassiopeia: Loaded cost, including error correction and the audit exposure from the suspense account mismatch, comes to roughly four times the automation cost. Over eighteen months.

Marge: So the sixty percent cut didn’t save money. It moved the cost off a project budget line and onto a person’s calendar, where nobody was tracking it.

Feld: (quietly) That’s a hard thing to hear out loud.

Thorne: It’s a common one. Not just here.

Vex: This is the burden rate problem. Everyone compares the sticker price of automation to zero, because the manual work doesn’t show up as a line item. It shows up as somebody’s Tuesday.

Feld: Walk me through the four times number. I want to understand it, not just accept it.

Ai. Cassiopeia: Certainly. Oskar’s estimation time alone, at a conservative hourly rate, accounts for roughly a quarter of the total. The remainder splits between error correction cycles, the audit review now required because of the suspense account mismatch, and the opportunity cost of Oskar’s time not spent on work that was actually his job.

Sable: That last piece is easy to miss. Oskar wasn’t hired to manually reconcile a rebate accrual every month. He was hired for something else entirely. Every hour on this was an hour not spent on the work Contoso actually needed from him.

Feld: (long pause) Nobody put a number on that when I made the cut. I don’t think anyone even thought to ask.

Marge: Most cuts like that don’t get asked. That’s usually the point at which they get approved.

Feld approves the automation on the spot. Oskar, watching from the doorway, doesn’t say anything, but he sits down for the first time in the whole engagement.


The cost that never shows up on a budget line

The sixty percent cut looked like savings because the alternative, eighteen months of Oskar’s labor, never appeared anywhere that got measured against it. That’s the actual mechanism at work here, not bad faith, not incompetence, just an asymmetry in what gets counted. A line item for automation shows up clearly on a project budget, with a number attached and a person accountable for approving it. The cost of not building that automation shows up nowhere, scattered across someone’s calendar in small enough pieces that no single month of it ever looks alarming.

Sable’s point about opportunity cost is the one that usually gets missed entirely, even in a careful accounting. It’s not just that Oskar spent time on manual reconciliation. It’s that that time came from somewhere, from whatever Contoso actually hired him to do, and that displaced work never shows up as a cost either. It just quietly doesn’t happen, or happens later, or happens worse, and nobody connects it back to a budget decision made eighteen months earlier in a different meeting entirely.

This is the same math behind almost every automation decision that gets deferred rather than rejected outright. The sticker price is visible and specific. The cost of the status quo is invisible and diffuse. Comparing a visible number to an invisible one isn’t really a comparison at all, it’s a bias built into how the decision gets framed before anyone even sits down to make it. Feld didn’t make a bad decision eighteen months ago because he did the math wrong. He made it because nobody asked him to do the math at all.


What happens next

With the rebate automation approved, the party finally has room to breathe, three weeks out from go live, only to discover the next problem waiting isn’t in the ledger at all. It’s in the people who are supposed to be running the system come Monday morning, and a readiness assessment is about to reveal that most of them aren’t ready.

Next episode: Episode 10, The Wayfinder’s Gap


This is almost exactly the math behind the AI cost comparison piece Murray wrote on LinkedIn, sticker price versus burden rate, same trap, different technology. Gamifying the Enterprise: Game Mechanics for Continuous Proficiency is available now on Amazon: https://www.amazon.com/dp/B0GY3VWLVX

And if you want a framework for surfacing the real cost of the status quo before it gets buried in someone’s calendar, start here: adnd365.com/start

Cause of death: a button that already worked got wrapped in a chat box and called intelligent.


The feature existed before the demo did. Somewhere in the product, there was a dropdown, a rule, a scheduled job, something deterministic that took an input and produced a correct, predictable output every time. Then, at some point in the last two product cycles, that same feature got a new front door: a text box, a little sparkle icon, a placeholder that says “ask me anything.” Now, instead of picking a value from a dropdown, you type a sentence, wait a beat, and the same output appears. The presenter calls this AI. The room, primed by two years of hearing the word everywhere, nods.

Nobody asks the obvious question: was this better before, and did anyone check.

What actually happened

Somewhere inside a lot of “AI-powered” features sits a deterministic operation that a rule, a formula, or a simple lookup already handled correctly and quickly. Wrapping that operation in a natural-language interface doesn’t make the underlying logic smarter. It adds a translation layer, one that has to interpret an unstructured sentence and map it back onto the same structured operation the dropdown was already doing directly, with total accuracy, in a fraction of the time.

That translation layer isn’t free. It introduces a new failure mode that didn’t exist before: the AI misreading the sentence and selecting the wrong option, a phrasing the model hasn’t seen before returning an unhelpful answer, latency where there used to be an instant response. None of this is inherent to AI as a category. Plenty of genuinely AI-native capabilities do things no dropdown ever could: summarizing an unstructured document, drafting a first pass at something that has no single correct answer, flagging an anomaly buried in a pattern too complex for a fixed rule to catch. The problem in this specific demo isn’t that AI was used. It’s that AI was used to solve a problem that was already solved, by something more reliable, and the swap happened anyway because AI is what gets funded, marketed, and put on a keynote slide this year.

The tell is almost always the same: watch what happens when you ask the natural-language version to do something slightly outside the phrasing it was tuned on. The dropdown never had this problem, because a dropdown has no phrasing to be tuned on. It just has options.

Why it works on smart people

Nobody wants to be the person in the room who seems skeptical of AI in a year when every vendor, every board deck, and every competitor’s marketing has decided AI adoption is the metric that matters. Asking “why does this need to be a chat interface instead of the three-click menu it replaced” risks sounding like you’re behind, not like you’re asking a reasonable engineering question, and that social pressure runs in exactly the wrong direction. It rewards accepting the AI wrapper uncritically and punishes the person who’d actually stop to check whether it improved anything.

There’s a second, quieter dynamic on the vendor side that compounds this. Once a company’s roadmap and marketing commit to being an “AI-first” platform, there’s organizational pressure to retrofit AI onto existing features whether or not doing so improves them, because a product review, an investor update, or a competitive comparison chart wants to see the AI checkbox filled in across the board, not filled in only where it was actually the right tool.

The actual damage

This is the one that costs you reliability you already had. A feature that used to return the same correct answer every time now returns a slightly different answer depending on phrasing, and the variance itself becomes a support burden, because now every unexpected result needs to be triaged as either a real bug or a model doing something technically defensible but unhelpful. Power users, the ones who had the old dropdown workflow memorized and could execute it in seconds, are now slower, because the natural-language version, for all its friendliness, requires more typing and more waiting than the three clicks it replaced.

There’s a subtler cost too. Every AI feature added for marketing reasons rather than capability reasons dilutes the credibility of the AI features that are actually doing something new and valuable. Once a buyer has been burned by one chat-wrapped dropdown, they bring that skepticism to the next AI claim in the deck, including the one that might have genuinely deserved their trust.

The fix, if you’re the one presenting

Ask, honestly, before the feature ships: does the natural-language interface let the user do something the deterministic version couldn’t, or is it doing the same operation with more ambiguity and more latency. If the honest answer is that the underlying logic hasn’t changed, keep the dropdown, or offer both, and don’t spend the marketing budget claiming AI where the actual improvement is zero or negative. If the AI genuinely does something new, lead with that specifically, in concrete terms, instead of leaning on the word “AI” to do the persuading by itself.

The word was never the feature. The capability was, and a capability that already existed doesn’t become new because it learned to accept a sentence instead of a click.


The distinction here matters enough that I built around it. In Is Headless ERP Enough, or Just a Step in the Right Direction?, the “AI as the sole interface” section argues for AI genuinely load-bearing in the architecture, not a chat box glued in front of the same dropdown. That’s the version of AI worth demoing. Everything else in this autopsy is what it looks like when a team ships the coat of paint instead.