The part that makes you competitive is the part nothing covers.
Off-the-shelf platforms cover the common four fifths well, and there is rarely a good reason to rebuild that. The remainder is usually the thing the business is actually good at — and it ends up in a spreadsheet, because nobody built for it.
Thirty minutes · no predetermined package
Building is a decision, and it should be reached rather than assumed.
A custom build is a larger commitment than a configuration, and it earns its place only when a specific requirement cannot be met by something you already own. So the first work is not design. It is establishing what has already been tried, why each attempt stopped, and whether the constraint is even where the symptom is.
That evaluation sometimes ends with a recommendation not to build, and that is a real outcome rather than a polite one. When it ends the other way, the reason is written down — so that in two years somebody can check whether the reason still holds.
What this looks like from inside the business.
Every demo ends with a workaround rather than a feature.
A spreadsheet holds the logic that actually differentiates the business.
You pay for a platform and use a fraction of it, because the fraction you need is missing.
More than one vendor has tried this and none of it held.
Work moves between people by email, and the handovers are where things are lost.
Nobody can give a straight answer about cost, because nobody has scoped it.
Four mechanisms, and none of them is the software.
The problem was scoped to fit an available product
Vendors scope to what they sell. A requirement spanning intake, operations and finance gets divided into three purchases that each succeed while the problem persists.
Nobody wrote down why the last attempt failed
Without a post-mortem the next attempt repeats the same assumption. The most useful hour in a custom engagement is usually spent on what has already been tried.
Building was decided before the constraint was found
Symptoms surface where the work is visible; constraints sit upstream where it is not. Building at the visible end moves the queue rather than shortening it.
Accountability is distributed, so nothing can be decided
When four people each own a quarter of the problem, every solution needs unanimous agreement and therefore does not happen. Naming one accountable owner is often the whole intervention.
Six questions before changing anything.
Diagnosis first, and it is allowed to stop there.
There is no reference architecture for a requirement nobody has categorised. This is the sequence a custom engagement follows instead, and each layer is a gate rather than a stage.
What we would actually be doing.
Where this has already been built.
A platform built around one operation
Routing, ingest, portals and attribution — built because the process was the advantage, and nothing off the shelf modelled it.
See the platformWhen configuration stops being the cheaper answer
The specific tests we apply before recommending a build, and the cases where the honest answer was to stop.
ReadDiagnose, architect, build, run
How an engagement is sequenced so the first phase is in use before the second is scoped.
How we workWhat teams ask before they start.
What if you decide you are not the right firm for this?
We tell you, in the first conversation if we can see it that early. That is a better outcome for both of us than a scoped engagement neither party believes in, and it is the reason the first conversation is a diagnosis rather than a pitch.
Can we engage you for the diagnosis only?
Yes. It is one of the engagement structures and for some businesses it is the right one — you get the written diagnosis and the target architecture, and you take it to whoever builds it. Some businesses need the map more than the builder.
How do we scope something nobody has defined yet?
You do not. The diagnosis is scoped and the work after it deliberately is not: scoping a build before the constraint is established is how the previous attempts went wrong. The diagnosis ends with a defined scope, which is most of what it is for.
Who owns the code?
You do. The repository is created in your organisation from the first commit rather than transferred at the end, which is the arrangement that goes wrong. The same applies to the accounts, the data and the documentation.
Is a custom build more expensive to run?
There is a real ongoing cost and it should be named up front rather than discovered later. Against it: no per-seat licence on the part that matters, and no annual renegotiation with a vendor who knows you cannot leave.
Bring the spreadsheet.
The workaround is the specification. Tell us what is in it and who maintains it, and we will tell you whether this is a build, a configuration, or neither.