The request is never the problem
Someone asks for a report. What they need is to stop reconciling two systems that disagree. Someone asks for a field. What they need is for one person to own a number that currently has three owners.
Take the request literally and you will deliver it correctly, on time, and change nothing. The system grows, the symptom stays, and in eighteen months the same person asks for a second report.
So the first move is to find the question behind the request, which is usually the one nobody has said out loud. That is uncomfortable work, and it is the reason it gets skipped.
In a group, a bad process is not annoying. It is multiplied
In a single company a clumsy process costs a few hours a month and everybody routes around it. Across eight subsidiaries the same process is replicated eight times, diverges locally, and every year it survives makes it more expensive to unwind.
That is why the same symptom costs an order of magnitude more here than in the vendor case study, and why group-level ERP problems resist the fixes that work fine at company scale.
It is also why the cause is so often a governance gap rather than a design flaw. Nobody decided the group would work one way, so each entity decided locally, and the ERP faithfully encoded eight answers to one question.
Symptoms that almost always mean something else
A close that takes fifteen days is rarely an accounting problem. It is usually intercompany flows that were never agreed, reconciled by hand at the end of every period because agreeing them would have required an arbitration nobody wanted.
A consolidation the CFO fixes manually in a spreadsheet is not a reporting gap. It is a chart of accounts that was harmonised on paper and left divergent in practice.
Five subsidiaries solving the same problem five different ways is not a training issue. It is the absence of a decision, made visible. The ERP is not the problem. It is the record of a decision nobody made.
What we do instead of writing a specification
We trace the symptom back to the decision that produced it, and then we do the part most consultants avoid: we name who owns that decision. Not a team, a person, at the level with the authority to settle it.
Then we get it settled before anything is configured. A decision taken in a steering committee costs a meeting. The same decision discovered in a configuration workshop costs a phase, and the same decision discovered after go-live costs a rescue.
Sometimes the outcome is that no software should be built at all. That is a successful engagement, and we would rather tell you that than sell you a build.
This is what Clarity Before Code means in practice
It is not a preference for less code. We know when to build a thousand objects and when to build zero, and most consultants get both decisions wrong in the same project.
It means the code you end up with is deliberate and correctly sized, because the question it answers was actually asked. If the need is not clear, the solution is necessarily wrong, however well it is built.
The test is simple. Six months after go-live, can someone name the rule each customisation encodes, and is that rule still true? If not, you did not build a system. You built a record of a conversation nobody finished.