What the AI coding shift actually changed
It would be dishonest to write a page about custom software in 2026 as though the last few
years had not happened. They have, and the economics are genuinely different.
AI-assisted development has collapsed the cost of producing software. A build that would
have been quoted in months is quoted in weeks, and the narrow first version that used to
be a project of its own is now something you can have in front of users quickly. The
practical effect is that a whole class of problem is worth solving properly that simply
was not worth it before — the thirty-thousand-dollar problem that used to need a
hundred-thousand-dollar system.
So custom software is still the most expensive of your options, and we will keep saying
that, but the gap between building and buying is much narrower than the last quote you got
five years ago would suggest.
What did not get cheaper is the part that was always the real cost: deciding exactly what
the software has to do. Writing code was never the bottleneck in the projects that went
badly. The bottleneck was that nobody had established, precisely enough to build from, how
the work actually runs.
That is not a documentation exercise. It means finding out how the job is really done as
opposed to how the procedure says it is done; where two people in the same business
quietly hold different views of the same process and have never had to reconcile them;
which exceptions are genuine rules and which are one long-serving person's habit; what
happens when a job changes shape halfway through; and who actually owns a decision when
two departments both think they do. None of that is recorded anywhere. No model can read
it off your existing systems, because your existing systems do not contain it. It comes
out of sitting with the people who do the work and asking until the answers stop
contradicting each other.
The shape of the cost has therefore inverted. Clarifying the process used to be a short
preamble to an expensive build; now it is most of the engagement and the build is the
cheaper half. It is worth knowing that before you read anyone's quote, including ours,
because a quote that is mostly discovery is not padding — it is the honest allocation.
The clarity is worth having whether or not we build anything
This is the part we would most like you to take from the page. Because the process work is
now the substantial half, it has become something you can buy on its own and stop.
Once the process is mapped and the disagreements are settled, a fair number of businesses
look at the result and conclude they do not need a custom build. The requirements, written
down plainly for the first time, turn out to match a product they can buy — and now they
can tell, which they could not before. Or the answer is a policy change, or removing a step
nobody could justify, or giving one person clear ownership of a decision. Occasionally the
thing they were worried about turns out not to be the problem at all.
Every one of those outcomes leaves the business better off than it was, and none of them
spends a development budget. We would rather you got there than be sold a system you did
not need, and it is not a loss for us either: it is the same work, it just ends sooner.
It also makes the build decision a far better decision. If you do go ahead, you commit
knowing what the thing has to do, with the arguments already had rather than waiting to
surface at the worst possible moment. That is most of the difference between a project
that lands and one that quietly runs over.
If that is the part you want, it stands alone as business process improvement and does not
oblige you to buy software from us afterwards.
What actually justifies a custom build
Custom software still needs a reason that survives being questioned. In practice there are
only a few, and they are easy to test against your own business.
The first is that the way you do the work is the reason you win it. If your process is a
variation on how everyone else in your industry runs, a product already exists and it
will be better supported than anything we would write. If your process is genuinely
unusual — and some are — then forcing it into a generic product means either paying to
bend the product out of shape or bending the business to suit the software. Neither is
cheap, and the second one quietly gives up the thing that made you competitive.
The second is that you have outgrown a product you already bought. This is the most
common version we see, and it does not mean the original purchase was a mistake. Hyforce
Engineering had invested heavily in an off-the-shelf field service system designed for
basic service management, and as the business got more complex the system could not
follow: it would not integrate with their time tracking or quoting, it cost a lot in
licences for a limited set of functions, and every new business requirement hit a wall.
That is a solid reason to build.
The third is that nothing exists at all. Ordered Australia came to us with a draft
business plan, rough ideas and a logo, running boutique import services as high-touch
consultative engagements rather than simple transactions. There was no off-the-shelf
order management platform that matched that, so we built one.
The fourth is that a third-party tool has become the limit on your growth. Odaptic were
delivering survey and reporting solutions to their own customers on Microsoft Forms and
Power BI. The reports were elegant, but every new customer onboarding took significant
manual effort, which made growth expensive rather than profitable. The constraint was not
a missing feature. It was that their business potential was capped by a tool they did not
control.
If none of those describe you, the honest answer is to buy something, and we will say so.
When we will advise against it
We write custom software, so we have an obvious incentive to recommend it. That is
exactly why it is worth telling you where we have not.
A plumbing contractor asked us for a custom field-service system, and we prototyped one.
Working through it with them, the conclusion was that we should not build it. Their job
lifecycle — schedule, dispatch, site, invoice — is the same shape as most service
businesses in the country, and several mature products already do it properly. We told
them to buy one instead. They did, and it was the right call. That recommendation cost us
the development work, which is the clearest evidence we can offer that the advice is not
steered.
We will also push back when the problem is not a software problem. If the process itself
is broken, building software around it just makes the broken version faster and harder to
change. If your existing systems are individually fine and collectively disconnected,
that is an integration job, not a build. And if the requirement is still an argument
rather than a decision, the right next step is a prototype, not a project.
What we build
Most of our work falls into four shapes.
Internal operational systems. The system the business actually runs on: jobs,
projects, service work, purchasing, timesheets, compliance. Impact Plumbing's purchasing
system replaced freeform email requests across ten-plus active job sites, where a
purchasing officer was interpreting emails by hand, comparing prices in a spreadsheet and
re-entering everything to raise a purchase order. Hyforce's system now supports the
business across every level, from the director and sales team to admin staff and field
workers, covering projects, service jobs, timesheets and the sales pipeline.
Field and mobile apps. Software used outdoors, on a phone or tablet, by people
wearing gloves. Impact Plumbing's site supervisors select from an approved catalogue
rather than free-typing requests, mark items for return with photos and captured
signatures, and sign in and out digitally instead of filling in paper timecards.
Safeguard Formwork's warehouse staff record four photos of hired goods, truck weight,
registration and driver details on an iPad, and the system blocks a non-compliant truck
from leaving.
Customer-facing portals and products. Software your customers log into. Ordered
Australia's clients track order progress through manufacturing, customs and shipping,
upload and download attachments, and get updates in real time. Odaptic's customers now
sign themselves up and start working with no manual intervention at all.
Platforms you own rather than rent. Where a third-party tool has become the ceiling,
the replacement is built to be yours. Odaptic's platform runs on their own AWS account,
with DynamoDB absorbing survey response ingestion, Postgres on RDS handling structured
reporting cheaply, and a reporting engine built in Svelte with AG Grid and AG Charts
instead of a licensed BI tool, so they control the visuals completely.
Who this suits
The businesses we do our best work for have a process they understand well and can
explain, someone senior who will make decisions during the build rather than after it,
and a willingness to start narrow. They are usually somewhere between twenty and a few
hundred staff — big enough that the manual version genuinely hurts, small enough that the
decision does not need a committee.
Most of them are in construction, trades, field service, manufacturing or professional
services. That is not a restriction, it is just where we have spent the most time, and it
shows in how quickly we understand what you are describing.
How a build runs
Discovery. We work out how the job is done now, including the spreadsheet on the side
and the steps nobody wrote down. Where we can, we watch the work rather than only asking
about it, because the gap between the documented process and the real one is usually where
the requirements are hiding.
Scope, then a prototype. The single most expensive failure in custom software is the
client and the developer picturing different products and not finding out for six months.
A written specification does not prevent it, because two people read the same sentence
differently. Something you can click does. So we build the narrow version early, put it
in front of the people who will use it, and let the disagreements surface while they are
still cheap. That is a
rapid prototype, and it is often a separate, smaller engagement
before anyone commits to a full build.
Build the smallest valuable thing, then extend it. With Hyforce we started with a
basic project management system — a custom web interface and mobile app handling essential
project tracking — got it into users' hands quickly, and grew the field service system
progressively as real usage told us what was next. Impact Plumbing's workforce management
started as a sign-in screen bolted onto the purchasing app staff already knew, then added
scheduling, pre-start roll call and live dashboards over the following weeks. Both systems
are larger now than anything we would have specified up front, and neither needed a
rebuild to get there.
Testing and rollout. Structured testing before release, then a phased rollout.
Safeguard Formwork went live at one warehouse first, collected feedback, then went
company-wide with training for warehouse staff and drivers. Impact Plumbing's rollout
needed real change management: sixty staff and ten to fifteen supervisors had to give up
email and spreadsheets, so onboarding, help documentation and ongoing support mattered as
much as the software.
Support, and the next change. The build is not the end of it. When Impact Plumbing's
director decided staff wellbeing was a priority, mental health check-ins were in the app
within a week. That responsiveness is the actual return on owning your own system.
Security, your existing data and the systems either side
New software rarely stands alone, and the connections are where projects get expensive
late.
We build in your tenant or your cloud account, not ours. Impact Plumbing's and Hyforce's
systems run on the Microsoft Power Platform and Office 365 licensing those businesses
already pay for, which is a large part of why they cost what they did. Odaptic's platform
runs on AWS under their control, with user management, multi-factor authentication and
password resets handled by Amazon Cognito rather than something we invented.
Access control gets designed deliberately, because a field worker, a supervisor and a
director should not see the same things. Existing data gets migrated with an explicit
decision about what comes across, what does not, and what history you are prepared to
lose. And where the new system has to exchange data with accounting, project management or
a vendor platform you are keeping, that is
systems integration work running alongside the build.
What you own at the end
You own the system, the data and the accounts it runs in. Odaptic's whole reason for
moving off Microsoft's SaaS tools was to invest in a platform they would completely own,
and that is the normal arrangement rather than a special case. Nothing we build is
licensed back to you, and nothing depends on us continuing to be the people who maintain
it.
That is deliberate, and it is the same principle behind our
software selection work: the deliverable has to be able to survive
being handed to somebody else. If it cannot, we have sold you a dependency rather than a
system.
What we can and cannot promise on results
Some of the results are measurable and published. Impact Plumbing's purchasing system
saves the purchasing officer up to twenty hours a week by automating supplier price
comparison and purchase order creation, across ten-plus job sites, and it has processed
hundreds of purchase orders a month since launch. Monthly supplier price updates that used
to take nearly a week are now an upload.
Others are real but not numeric, and we would rather say that than invent a percentage.
Safeguard Formwork's compliance system was never about efficiency — it was about being
able to prove the condition of hired goods when they left the yard, which is worth money
only on the day something is disputed. Hyforce's licensing costs came down because the
system runs on Office 365 they already had, and their operational agility went up, but
the honest framing is that the system now changes when the business does instead of
blocking it.
What we will do before starting is tell you which kind of result you should expect, and
what we would measure to know whether it happened.