For twenty years, the responsible advice was don't build software. Buy it.
That advice was right. Custom software was slow, expensive, and risky. A mid-market company that built its own tools was usually lighting money on fire, and every CFO who said "just get the SaaS" was doing their job well.
The costs that advice was calibrated to no longer exist.
AI-assisted development changed the economics of building software more than anything I have watched in my career. I run a custom software firm, so you should weigh my incentive here, but I am not guessing at this from the outside. Work that used to take a team two quarters now takes a couple of engineers a few weeks. Not sometimes. Routinely. The bottleneck moved from writing the code to deciding what the code should do.
We eat our own cooking on this. Our company runs on an operations platform we built ourselves, covering finance, projects, and sales pipeline, plus a prospecting system wired into the tools we already pay for. A few years ago, building that instead of buying it would have been irresponsible. Today it was the obvious call, because it fits how we actually work instead of how a vendor imagines companies like us work.
That fit is the part of the math everyone underprices.
Look at the SaaS line items on your P&L. The license cost is the visible number. The invisible number is the contortion cost — all the ways your team bends its process around what the tool allows. The workflow that takes six clicks because the vendor built for a different industry. The export to Excel because the report you need does not exist. The two systems that do not talk, reconciled by hand every month. You are paying per seat, forever, for software that fits maybe 70 percent, and your people donate the other 30 in workarounds.
When building was expensive, tolerating that was rational. Now the tradeoff deserves a fresh look, and the answer will not be the same one you got in 2019.
Before this reads as build everything, let me be honest about the other side, because there are real tradeoffs and the new failure mode is already visible.
Software you build, you own. Forever. AI collapsed the cost of writing code. It did not collapse the cost of running it. Hosting, security, backups, the upgrade when a dependency goes stale, the fix at 4pm on a Friday. Anyone who tells you AI makes that disappear is selling something. Owning software is a responsibility, and you should only take it on where the ownership pays you back.
Which means the old rule does not reverse. It sharpens.
When building gets cheap, the risk stops being the expensive failed project and becomes sprawl. Ten half-finished internal tools, each built in an afternoon, none maintained, is not a capability. It is a mess with version control. Cheap to build makes discipline more important, not less. Fewer systems, owned properly, beats many systems owned by nobody.
Here is the exercise, and it takes one meeting. List your SaaS subscriptions. Next to each one, write down what your team does to work around it.
That is the shortlist. Not build everything. Build that.
The advice you got five years ago was right five years ago. The companies that notice the math changed before their competitors do are going to own their edge, literally, while everyone else keeps renting a 70 percent fit.
Which tool does your team complain about most? Start the list there.