Build with AI or Buy: Build Time Is the Cheapest Line on the Invoice

A finance manager spends every Friday afternoon reconciling vendor invoices against purchase orders. Two spreadsheets, one folder in SharePoint and a lot of copy and paste.

One Thursday, she opens an AI assistant and describes the task. By the end of the day, she has a working app. It reads the folder, flags the mismatches and posts a summary to a Teams channel.

Friday afternoon is free.

Leadership sees the demo. Everyone is impressed. Before long, two other departments want one.

But seven months later, the summary stops showing up in Teams.

Nobody notices for three weeks because nobody is doing the Friday reconciliation by hand anymore. When someone finally looks, the app has been failing silently since the credential it was running on expired. The person who built it moved to a new role in the spring. Nobody else knows how it works.

The invoices still got paid. Some of them twice.

The short answer: When you weigh build vs. buy for AI, the build is the cheapest part. The real cost is owning the app after the demo: identity, secrets, monitoring, budget, data review and long-term maintenance.

Before you build, decide who owns it for the next five years.

Why the Build vs. Buy AI Question Is Harder Than It Looks

Build vs. buy used to be a fairly straightforward question. Building was slow and expensive, so you typically built when nothing on the market fit. Buying was faster, but it meant living with someone else’s design limitations.

AI has changed the first half of that equation dramatically.

A working prototype can now take an afternoon. And when you see something go from idea to working demo that quickly, it’s easy to conclude that the balance has shifted. Why wouldn’t we build more of these things ourselves?

But I think that conclusion exposes a mistake we’ve been making for a lot longer than AI has been around.

The Mistake: Treating the Cost of Building as the Cost of the Thing You Built

It’s an easy trap to fall into because building is the part everyone can see.

The prototype is visible. The demo is visible. The hours spent creating it are visible.

Everything that comes after is mostly invisible. At least until something fails.

There’s an old, but excellent engineering comic about exactly this: https://xkcd.com/1319/.

The top panel shows the plan: a burst of work writing code, then automation takes over and free time stretches out to the horizon.

The bottom panel shows what actually happens. Debugging. Rethinking. A line labeled “ongoing development” that never comes back down. Underneath it, a dashed line for the original task with a note: no time for that anymore.

That comic was drawn long before anyone was generating apps from a chat window.

AI didn’t create this pattern. It just removed one of the brakes that used to slow it down.

What an AI-Built Prototype Leaves Out

A working prototype is a real achievement. But it’s also roughly a tenth of a working service.

Here’s what that afternoon build almost never includes.

  • Its own identity. The prototype ran as the person who built it, using her login, her permissions and her licenses. A service needs an identity of its own, with only the access it actually requires. Somebody has to grant that, review it and renew the credentials when they expire. In most environments, that expiration is the first time anyone realizes the app was never set up as a service at all.
  • A safe place for its secrets. The passwords and keys the app uses are sitting in the code or a config file. Moving them to a proper vault is quick. Deciding who can read them, who rotates them and who gets paged when one is about to expire is the part that gets skipped.
  • A way to know it’s broken. The prototype told the builder when something went wrong because the builder was watching. A service needs monitoring, an alert and a human who reads the alert. Without that, silent failure becomes the default state. The invoice app didn’t crash. It just stopped, quietly, while everyone assumed it was working.
  • A budget for running it. Cloud functions, storage, AI tokens, logging. Each one costs pennies in a demo and becomes a line item at scale. The business case was built around the hours saved. Nobody wrote down the other side of the ledger.
  • A review of what data it touches. The app moved financial records through an AI service and into a chat channel. The policies protecting that data were written with people in mind. The app walked around them, not out of malice, but because nobody stopped to ask the question.
  • Someone to keep it alive. Every library, API and AI model the app depends on will change on its own schedule. Someone has to notice, test and update. Then there’s the documentation, the handoff when the builder leaves and, eventually, the decision about when to retire it. None of that is in the prototype because none of it is necessary to make the demo work.

The Hidden Cost of Ownership That Compounds Over Time

The comic’s dashed line is the part I think leaders underestimate most.

Once the app exists, people stop doing the task by hand. That’s the point. But it also means the skill and the habit start to disappear. When the app fails, there may no longer be a fallback because the person who used to perform that process is now doing something else.

The manual cost didn’t disappear. It was converted into fragility.

And fragility doesn’t show up on a budget until the quarter it bites.

Now multiply that by the three or four apps that appeared after that first successful demo. Each one built by a different person. None of them clearly owned by anyone.

Pretty quickly, you have a quiet portfolio of unmaintained systems the business now depends on.

Build Time Is the Cheapest Line on the Invoice

If there’s one sentence I’d carry away from this, it’s this: Build time is the cheapest line on the invoice.

That was true before AI (think VM sprawl, cloud sprawl, etc.). AI has simply made it much easier to see because it’s driving that one line significantly down while leaving every other line where it was.

Three Questions to Ask Before You Build with AI or Buy

So I think we need to ask the build vs. buy question differently. Instead of asking, “How fast can we build this?” I’d ask three questions, in this order:

  • Should this process exist at all? Is the task stable and repetitive enough that a system will still fit it two years from now? Or is the manual process absorbing changes that a system would break on?
  • Who owns the solution for the next five years? Not a department. Not “IT.” A name. Someone with time budgeted to be responsible for the credentials, monitoring, updates and eventual retirement.
  • What does buying cost us, honestly? That includes the things we give up.

Sometimes, after answering all three questions, the answer is still build. And that’s perfectly reasonable. It should simply be a deliberate decision, not the side effect of a really good demo.

And if the second question has no answer, the first question may already be answered for you.

How We Approach AI-Built Prototypes That Became Business-Critical

When a client brings us a prototype that has become important to the business, we don’t start by assuming it needs to be rebuilt or replaced.

We start by understanding what it depends on and who would notice if it stopped working. Then we help make an intentional decision.

  • Maybe it becomes a supported service with an owner and a budget.
  • Maybe it gets replaced by something that’s already supported.
  • Or maybe it gets retired and the manual process is restored.

Any of the three can be the right answer. The bad outcome is letting something become business-critical without ever making the decision.

Two Questions Worth Sitting With

Here’s an exercise I think is worth doing with your team. Make a list of the tools your people have built for themselves in the last year. For each one, ask:

  • Can you name the person who would get the alert if it failed tonight?

    • And if the answer is nobody, ask one more

  • How long would it take you to find out?

Build time is the cheapest line on the invoice.

The rest of the invoice is still coming.

 

ABOUT INSITE BUSINESS SOLUTIONS:

Most West Michigan manufacturers know they need to connect their shop floor systems with their business systems. But figuring out how to bridge that gap is like playing vendor roulette. They often end up picking either an IT shop or an automation house, or a combination of both. 

InsITe has IT and OT engineers on staff. One call, one team, one point of accountability across the full tech stack. Before we recommend anything, we walk your shop floor and then design the solution, execute the implementation, and own the outcome through managed services, security, and ongoing support. 

If you're looking for IT or OT help from people who understand the ins and outs of manufacturing, we can help. 

Talk to an Advisor Today →

Back to Blog