A borrower uploads a 20-page document. It has 19 pages.
That sounds like a small problem. It isn’t.
The core system can process the document perfectly well. The problem is that someone needs to recognize that page 3 is missing, understand what that means, and trigger whatever needs to happen next. Historically, we solved that kind of problem with people, point solutions, workflow tools, OCR, RPA, and a lot of custom integration.
Why? Because software was expensive to build.
Now put an LLM in the middle of that process. It can look at the document, recognize the pattern, understand that a page is missing, and call software to send a note asking for it.
That is a very different economic proposition.
I think this is where a lot of the build-versus-buy conversation is going wrong. People see AI generating working software and jump to, “We should build everything.”
That’s the surface-level analysis.
The more interesting question is what actually changed.
When I got into the industry, good software engineering was scarce. Companies competed aggressively for engineers because writing software that actually worked at scale took time and expertise.
AI has changed that almost overnight.
We can write code faster. We can test it faster. We can deploy it faster. We can take something that would have required a significant engineering investment and get to a working version much more quickly.
That matters, but writing code is only one part of building software.
Enterprise systems still require architecture, security, integrations, testing, governance, operations, and accountability. Those things do not disappear because an AI agent can produce ten thousand lines of code.
So, I don’t think the right conclusion is that everything should now be built.
I think we need to look at where the new abundance actually changes the economics.
There are large, established systems that solve fundamental business problems. Think of the major platforms that run mortgage, banking, insurance, or capital markets operations.
We are not going to replace those systems simply because AI can generate code.
Those platforms contain years of business knowledge, integrations, data, controls, and operational experience. Recreating all of that still takes time.
What AI does give those vendors is a massive new advantage.
They can fix more bugs. They can improve their software faster. They can modernize their platforms. They can reduce the cost of maintaining them.
So, I think buyers should start asking their core software vendors a different question:
“I understand that engineering has become more abundant. How are you sharing that abundance with me?”
That is a procurement question now, and it is going to become a bigger one.
Once you have dealt with the core, the interesting part starts.
Around every major enterprise system, there is a layer of work that is much harder to standardize.
This is where you find OCR, document ingestion, RPA, customer interactions, exception handling, manual handoffs, and all the other “last mile” problems.
The old software model worked reasonably well here. A point solution could solve the common case, perhaps 60% of the problem, and the remaining variability stayed with people.
The economics made sense because building software to handle every variation was too expensive.
AI changes that.
Large language models are unusually good at handling variability. They can look at something that does not match the expected pattern, interpret it, and determine what should happen next.
That is why I think the biggest build-versus-buy shift is happening at the edge, because AI has made it far more economical to build around the core.
We recently built a last-mile capability in about a week that historically would have taken six to 12 months of engineering. That is not a universal delivery promise. It is an example of how dramatically the economics can move when you combine software engineering abundance with AI’s ability to handle variability.
And that changes the question enterprises should be asking. Instead of asking whether to build or buy an entire system, ask which parts of the workflow are now economical to build yourself.
Once you start building at the edge, another pattern emerges
The first workflow may be document heavy. The next one may involve customer communication. Another may involve exception handling.
The business processes look different, but a lot of the underlying technology is the same.
Document intelligence. Unstructured data. Communication. Workflow orchestration. System integration.
You build those capabilities once and reuse them.
That is where the economics start to compound. Instead of buying five different SaaS products to handle five different edge cases, you can invest in an engineering capability and extend it across the organization.
This is especially interesting for smaller companies. They can move quickly. They do not need a massive engineering organization. One good engineer sitting at the edge of a business process, equipped with AI and given the right business context, can accomplish a surprising amount.
That is the shift: AI makes the edge more buildable, while reusable capabilities make that investment more scalable.
That is the opportunity.
I would keep the core systems and look hard at the edges.
Find the processes where variability creates manual work. Find the workflows where employees spend their time interpreting exceptions. Find the places where you are paying for software that solves most of the problem and people to handle everything else.
Then ask three questions.
Can we improve the existing system?
Can we buy the capability at the right economics?
Can we build it ourselves now that engineering has become so much more abundant?
The answer will vary by process.
What has changed is that the third option deserves serious consideration in places where it never did before.
That is the real build-versus-buy story.
AI has not made enterprise software simple. It has made software engineering more abundant and software much better at handling variability.
If you combine those two things in the right place, the last mile becomes a place worth building.
