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

Previously on: Episode 12, The Customization Nobody Remembers, Vex found a two year old tax override still running on top of a platform fix that made it unnecessary eighteen months ago, which meant international tax had likely been calculated twice for a very long time.

Two weeks to go live, and the party finally has to decide what to do with a discovery that’s bigger than a bug fix. This episode is about the moment a technical finding becomes an ethical one.


The Session

Vex: The override was patching a tax bug. The bug was fixed in a platform update eighteen months ago. Nobody removed the patch.

Sable: So for eighteen months, international tax has been calculated twice. Once correctly by the platform, once again by the leftover override.

Thorne: Every international order in that window needs review.

Ai. Cassiopeia: I can generate the affected transaction list. It is not small.

Marge: Feld needs to know today. Not after go live.

The party requests an unscheduled meeting. Feld reads the summary standing up, without sitting down first, which everyone in the room understands as a bad sign before he says a word.

Feld: (reading the list) This goes to audit and legal before it goes anywhere else.

Thorne: That’s the right call. It’s not a great one. But it’s the right one.

Feld: (setting the list down carefully) Two go live attempts failed because people were afraid to bring me news like this. You just did it anyway.

Marge: That’s the job.

Feld: I know it is. I’m still noticing that it happened.

Vex: There’s a smaller silver lining, if it helps. The overcorrection was consistent and directional. It should make the reconciliation methodical rather than exploratory. We know exactly what we’re looking for.

Ai. Cassiopeia: I concur. This is not a needle in a haystack. It is a known pattern applied against a known window.

Feld: (a short, tired exhale that’s almost a laugh) After everything else this project has thrown at me, “at least it’s a known pattern” is genuinely reassuring. That says something about the last four months.

Sable: It says the bar moved. Not that this is small.

Feld: Understood. Bring in whoever you need. What does the timeline look like with audit and legal both in the loop?

Feld authorizes disclosure, pulls in audit, and, for the first time in the engagement, asks the party what go live actually needs from him personally.


The moment disclosure stops being optional

Every episode up to this one has been about finding a problem and deciding how to fix it. This one is different, because the discovery crosses a line where “fix it quietly and move on” was never actually on the table. A tax miscalculation across a known window of international orders isn’t a configuration issue the team gets to resolve on its own judgment. It has legal and regulatory weight that belongs to people outside the war room, and pretending otherwise, even with good intentions, would have been a much bigger risk than the original bug.

What’s worth noticing is how unremarkable the decision to disclose actually was, once it got made. Marge’s line, “Feld needs to know today, not after go live,” isn’t dramatic. It’s the obvious, boring, correct call, and it’s only notable at all because of everything the party has learned about this project over twelve episodes: two prior go live attempts where the vague language of “data quality issues” let real problems go unnamed. Feld himself sitting through disclosures he could have made and didn’t. The default on this project, before this episode, was to let uncomfortable news dissolve into something softer before it reached the person who needed to hear it clearly.

Feld’s response is the real payoff of everything episode seven and eight built. He doesn’t get defensive. He doesn’t ask if it can wait. He reads the finding standing up, makes the harder call immediately, and then does something a lot of sponsors never manage: he notices out loud that the team told him the truth without being forced to, and says so, rather than treating honesty as the baseline he was owed all along.


What happens next

Audit and legal are engaged, the timeline is adjusted to account for it, and the party heads into the final stretch with every major fire from the last twelve episodes either resolved or actively being managed in the open. Cutover weekend arrives, and every fix built over the course of this campaign gets tested at once, live, in front of the whole company.

Next episode: Episode 14, Go Live Weekend, the campaign finale (coming soon)


If your team has ever found something that needed to go to legal or audit before it went anywhere else, you know exactly how heavy that meeting feels. 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 surfacing findings like this one clearly and early, instead of letting them soften into something vaguer, start here: adnd365.com/start

In 2009, a former branch manager at Randstad was sentenced to five years and one month in federal prison for wire fraud and aggravated identity theft. The scheme ran for three years before anyone caught it. The method behind it was almost boring, which is exactly why it worked.

What happened

Cynthia Whitehead used the real names of former Randstad employees, people who had already left the company, to generate wage payments through the payroll system. She then kept those “wages” for herself. From 2004 to 2007 she embezzled more than a quarter of a million dollars this way. She pleaded guilty on July 8, 2009, and was ordered to pay $286,388.37 in restitution on top of the prison sentence.

Nobody defeated a clever fraud control here. The scheme worked because a former employee’s identity remained valid and payable inside the system long after that person had stopped working there.

Why the gap existed

The failure point sits exactly at the boundary between two systems that were supposed to agree with each other: HR, which knew someone had left, and payroll, which kept generating payments as if they hadn’t. That boundary is where this kind of fraud always hides. It isn’t defeating a rule. It’s exploiting the fact that two systems of record were allowed to disagree for as long as nobody checked.

A termination event should be the kind of thing that instantly and automatically closes off every downstream ability to pay that person again. In practice, in a lot of ERP implementations, it’s a status field that gets updated in one module and trusted to eventually matter everywhere else. Three years of undetected fraud is what “eventually” costs.

Controls that would have caught it

The control here isn’t exotic. A payroll run should not be able to issue a payment to any employee ID with an active termination date, full stop, checked at the moment of disbursement rather than assumed from a status flag set once and never re-verified. In practice, this means the integration between the HR module and the payroll module needs to function as a hard gate on every pay run, not a background sync that payroll happens to respect most of the time.

The harder part isn’t designing that rule. It’s noticing that it needs to be designed at all, because on paper the termination process already “worked.” The employee’s status did get updated. Nobody had built the check that made that status update actually block a payment.

An AI prompt example for ERP fraud detection

This is a case where an AI-assisted review layer earns its keep, not by replacing the underlying control but by making it cheap enough to run constantly instead of only during an annual audit. Against the ERP’s HR and payroll data, a controller could run something like:

“List every payroll disbursement in the last three fiscal years paid to an employee ID with a termination date recorded prior to the pay period start date.”

A second, complementary query catches slower variants of the same pattern:

“Flag any employee ID that received a payment more than 30 days after their most recent termination or leave-of-absence date recorded in HR.”

Neither prompt requires new system functionality. Both require someone to think to ask the question on a recurring basis rather than only after a tip or an audit forces the issue. That is the actual lesson of this case. The rule that would have stopped it wasn’t complicated. It just wasn’t being asked.

The pattern for this series

This is the first case in a series looking at real, documented ERP fraud schemes: what happened, what shared assumption in the underlying system let it run, what a properly governed control looks like, and a concrete AI prompt that turns a periodic audit question into something that can run continuously. The goal is never to suggest AI replaces the governance. It’s to show what becomes possible once the governance exists and someone actually asks it the right question.

Source disclaimer

The case details in this article are drawn from a press release published by the U.S. Attorney’s Office for the Northern District of Georgia, a public government source. All facts, figures, and quotations describing the case are sourced from that release. The analysis of the control gap, the proposed detection controls, and the AI prompt examples are original commentary and are not part of the source material.

References

United States Attorney’s Office, Northern District of Georgia. “Former Randstad Branch Manager Sentenced to Federal Prison for Embezzlement.” Press release, September 16, 2009. https://www.justice.gov/archive/usao/gan/press/2009/09-16-09c.pdf

Cause of death: the competitor being demoed against would not have recognized itself.


Midway through the pitch, the slide changes to a comparison. Two columns, sometimes three. Your product on one side, the competitor on the other, a row of checkmarks and X marks running down the middle. The competitor’s column is thinner than it should be. A feature they shipped eighteen months ago is marked absent. A limitation they fixed two releases back is presented as current. The pricing comparison uses the competitor’s list price against your negotiated discount. By the end of the slide, the choice looks obvious, because one column was built by a team with every incentive to make it look that way, and the other was built by nobody in the room.

Nobody in the room raises a hand and asks when this comparison was last verified. That’s the autopsy. A competitive comparison built entirely by one side, unchecked by the other, isn’t a comparison. It’s a résumé written by an opponent’s rival, and it gets read with the same scrutiny either way, which is to say, functionally none.

What actually happened

Every competitor’s product roadmap moves faster than any comparison sheet does. A gap that was accurate when a sales engineer built the deck eighteen months ago has, more often than the room assumes, already been closed, sometimes through a native feature, sometimes through a partner integration or a marketplace add-on that isn’t visible from the outside but is entirely visible to the competitor’s actual customers. The comparison sheet is a snapshot with no expiration date printed on it, presented as though it were current.

The pricing rows compound the distortion in a specific, predictable direction. List price for the competitor, negotiated or promotional price for the vendor doing the presenting, is close to the default comparison method, and it isn’t dishonest in the narrow sense, both numbers are real, but it compares two different stages of the same negotiation, one that hasn’t happened yet against one that has. A prospect who hasn’t negotiated with either vendor is looking at the least favorable version of one price and the most favorable version of the other.

Feature checkmarks suffer the same collapse the Security Theater Demo’s checklist suffered. “Supports multi-currency” or “has a mobile app” is either true or false on the slide, with no room to indicate that one vendor’s version is a fully native capability and the other’s is a third-party add-on with a separate contract, a separate support line, and a separate bill.

Why it works on smart people

A side-by-side comparison has the visual grammar of objectivity. Two columns, symmetric formatting, a neutral-looking checkmark or X, all of it borrows the credibility of a spec sheet or a lab test, something that feels like it was measured rather than argued. The room’s guard is lower here than almost anywhere else in the demo, precisely because the format looks like data rather than persuasion, even though the party assembling the data has an obvious and undisclosed conflict of interest in every cell.

There’s also a research-avoidance effect. Verifying even a handful of rows against the competitor’s actual current documentation, or a call with their team, takes real time that a sales cycle often doesn’t budget for, and the comparison slide offers a shortcut that feels like due diligence without requiring any. Accepting the slide as accurate is the path of least resistance, and it’s a path built specifically to be the easiest one to take.

The actual damage

This is the one that produces a decision built on a comparison that was already stale, sometimes badly, by the time the contract was signed. A capability marked absent for the competitor that had actually shipped means the losing vendor was disqualified on a false premise, and the winning vendor’s genuine advantages, whatever they actually were, never had to be defended on their own merits because the comparison did the work for them.

Once implementation starts, the gap between the comparison sheet and reality becomes the buyer’s problem, not the vendor’s. If the deciding factor was a feature gap that didn’t actually exist, the buyer is now living with a vendor selected on the wrong basis, discovering the real trade-offs only after the switching costs have become substantial.

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

If you’re presenting, date every comparison row and be specific about the source, and if there’s a real chance a competitor has closed a gap since, say so rather than let a stale advantage stand unchallenged. If you’re buying, treat any vendor-supplied comparison as a hypothesis to verify, not a finding to accept. Take the three or four rows that would actually change your decision and check them directly against the competitor’s current documentation or a live conversation with their team, rather than checking all thirty rows equally or none of them at all.

A comparison chart built by one side and verified by neither side is not a comparison. It’s an argument wearing a spreadsheet’s clothes, and it deserves exactly the scrutiny an argument gets, not the trust a measurement earns.


The Waterdeep Trading Company runs on the same principle at its literal gates. In Receiving Controls That Stop Bad Goods, nothing becomes sellable stock on the strength of a seal or a claimed count alone. It gets checked at the gate, every time, regardless of who’s vouching for it. A competitive comparison deserves the same standing policy: verify before it enters the decision, not after.

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.