In ten years, I think I rang our software supplier's support line once.

You might reasonably assume that meant the product was working. Mostly, it was. But I still dreaded any contact with them, because every call had quietly become an aggressive sales opportunity. Ring up, and somewhere in the conversation there would be something new to upsell. When I say somewhere, I can narrow it down to the start, middle and end. A new product or seminar? They were always keen to talk. The rest of the time, you were nudged towards the help files and the chatbot — every call treated as a cost to be deflected.

I only realised afterwards how draining that had become. Not the money — the guardedness. When every conversation with a supplier needs your hand on your wallet, the relationship is already over. You just haven't done the paperwork.

None of that is unique to them, which is rather the point. I don't think any of the big vendors are fundamentally different, and I don't think they're about to be. I suspect the whole industry is heading the same way. So when the relationship starts to feel less like a service and more like being sold at, switching to a competitor probably won't fix anything. You migrate, at real cost and real risk, and land on a different compromise run in much the same way. And the migration you've just done was a massive hassle and time sink.

Which leaves one option, if you have the confidence and discipline for it.

Stop renting the compromise, and build the parts you actually need.

I have written before — unsparingly — about how badly that can go. These tools will happily seduce you into trusting things you shouldn't. But this is the other half of that story. Because once you have the discipline to build safely, what you get in return is a system that finally fits.

Let's be clear: this wasn't a whim. What we replaced eventually came to around 40,000 lines of code. Not a weekend of vibe coding — a proper piece of engineering. But we knew we could do it, and the sums were compelling.

We were coming up to another three-year commitment. Between the PSA and the documentation platform that had quietly accreted alongside it, we were paying £140 per named user per month — £90 for one, £50 for the other — with a five-user minimum. £700 a month, every month, before you got to the other tools and bolt-ons around it. I had honestly forgotten the documentation platform was even in the stack until I went back through the bills — which rather proves the point. Over the three-year term we were about to re-sign, that was a £25,200 commitment.

We'd save the money, which mattered more than I'd care to admit. We'd be out of the lock-in, and out of the penalty you pay for the sheer impertinence of wanting flexibility.

And the cost didn't just affect the bill. It affected our behaviour.

There were occasional users who ideally should have had their own accounts — accounts, admin, the odd job here and there. But when every named licence carries that sort of monthly cost, locked in for three years, you start making compromises you know aren't ideal. You ask whether two occasional users really need two separate logins, or whether the business can live with a loss of neatness and accountability because the alternative is another recurring cost line.

That's the small-business reality many software vendors seem to miss. £90 a month here, £120 a month there, another bolt-on somewhere else, and suddenly "just another licence" is not just another licence at all.

We were paying, on a multi-year commitment, for something that did perhaps 80% of what we actually needed — and increasingly without the sort of relationship behind it that made the missing 20% bearable. And even the 80% it did do often made you work for it.

Here's the thing I really want you to take from this, because it is where the decision usually goes wrong.

You don't replace the system.

You do replace the part of it you actually use.

A commercial PSA does a thousand things. We used a fraction of them. There was never any question of rebuilding the lot — and "not compromising" does not mean building something vast. It means the opposite. It means pulling exactly the list of machines and exactly the list of faults we need, and nothing else, until the day we need something more. At which point we change it.

Off-the-shelf software is a compromise by design, because it is built for the average of thousands of businesses. If you're not careful, it nudges you towards average too. Bespoke fits the one business it is actually for.

Three things made that concrete.

The first was the dullest, and my favourite. We made logging a quick support job genuinely quick.

Our system has a deliberately simple route for the small jobs: pick the client, type a brief description, enter the time, done. ABC123, move on. The old system may well have had some configuration path that could have got us closer, but too often it felt like wrestling with mandatory fields and irrelevant workflow steps: "You cannot save because you have not specified..." — give me strength.

What we only realised afterwards was the behavioural effect. Under the old system, quick jobs were the ones most likely to disappear. You would look at something that took a few minutes and think: it is not worth the admin, move on to the next fire.

In IT, work often arrives in bursts, and those little jobs add up. Everyone is happy to give a customer ten minutes here and ten minutes there. But string a whole morning of those together, and the record makes it look as though you did nothing at all.

We log more because logging no longer feels like a punishment. Fit did not just save time. It stopped the tool lying about the shape of our day.

The second was joining up the chain we actually run: quoting, into the project, into billing, as one straight-through flow.

The quoting in the old system was too labyrinthine for the way we worked, so we had ended up with a separate quoting product alongside it. That was another cost, another product, another little island. Eventually we stopped using that too, and did the extra work manually.

So we rebuilt only the path we used every day, and made it fit that path exactly. Not more capable than what we left. Less, precisely.

The third was putting commercial reality where we actually needed it.

The old PSA didn't give us useful licensing visibility. It didn't connect that world up in the way we needed. So we built that slice ourselves. We can now tie products, contracts and licences to actual people inside actual client organisations.

That sounds like a small distinction, but it changes the job completely. Onboarding and offboarding stop being a memory test. If someone leaves, we can see what is attached to them. If a client is paying for something, we can see who it belongs to. If nobody owns it, that's a question in itself.

That's the sort of thing generic systems often miss. Ours did. They may have a field somewhere, or a notes section, or a module that nearly fits. But "nearly" is where the work hides. We didn't need a more elaborate system. We needed one that understood our path through the work.

And one more thing we added that no off-the-shelf tool had ever given us in a way we actually used: a simple risk register.

If a client decides on something an engineer thinks is unwise — their call, but noted — that judgement now lives in the system. So when that engineer is on holiday and someone else picks up the account the next day, they don't walk in blind, wondering what on earth is going on. You'd think every system would have this already. Seems not.

It captures not just the data, but what we thought. That's the part that used to walk out of the door with whoever happened to know it.

Now the part these stories usually leave out, because it is the price of all of the above.

There is no vendor to ring any more. When something breaks, it's mine — not a supplier's problem at three in the morning. Mine. And it always will be.

If something doesn't get logged now, there's no tool to blame; it's just us being lazy. I have traded a supplier I could hold responsible for total control I am now wholly responsible for.

And there is one specific, honest cost worth naming: reporting.

The old system's reporting was mature — arguably too mature, so elaborate that I was realistically the only person who could drive it. Ours gives us precisely the reports we want, and nothing we don't. But the moment we want a report we haven't built yet, that's not a menu option. That's code someone has to write.

There is no report you can't have.

But every single one of them is a job.

I would make the same call again tomorrow. Not because what we built is "better" than what we left — a solo build is not going to out-engineer a product with hundreds of developer-years in it, and it doesn't need to.

It's miles better for us.

And that's a different, and far more achievable, thing. What we have now fits, costs and all, and it is not quietly trying to sell us anything.

Mostly, it feels like ours. The whole thing — from quoting a piece of work, to doing it, to billing for it — feels in our hands in a way it had not for years. That control comes with a bill you keep paying: in maintenance, in responsibility, and in reports you have to write yourself.

But for us, it's worth every line of code.

And where does AI fit into all of this?

Everywhere. It's the reason this is a story from this year and not a fantasy from ten years ago.

Bespoke software has always fitted better. That was never the question. The question was cost: 40,000 lines of proper engineering used to mean a development team and a budget no five-person business could justify. AI-assisted development has collapsed that — not to zero, and not to a magic weekend, but to a few disciplined weeks instead of years of someone else's roadmap.

The build-versus-buy line has genuinely moved. Most small businesses haven't noticed yet.

But be careful with that sentence, because it's only half of one.

AI has made this possible. It didn't make it safe.

The discipline that kept 40,000 machine-written lines honest — what we checked, what we didn't trust, and the bug that nearly got through anyway — is a story of its own.

This article first appeared on LinkedIn, which is where the discussion is.