We Built It. Then We Bought It.
Sometimes good engineering means walking away from something you built well. A real-world build-versus-buy story about evidence, sunk cost, engineering judgment, and knowing when simpler is better.
Sometimes good engineering means throwing away good engineering.
By Prateek Sharma, MCA
I built the thing.
A custom telephony pipeline for Bradley, our conversational facilities management assistant.
Streaming audio. Speech to text. Text to speech. All wired together by hand.
And it worked.
Then we tested a commercial product.
It worked better.
Well, crap.
The Build Wasn't a Mistake
Bradley needed to answer phone calls.
We already had the important pieces behind it: search, work-order logic, logging, and the rest of the infrastructure that let Bradley actually do something useful after a person said, "There's water leaking in the court building."
What we needed was the voice layer.
So I built it.
That was a perfectly reasonable engineering decision. We needed a capability. We knew how to build it. So we did.
But being able to build something doesn't automatically mean you should own it forever.
That's where this story gets interesting.
Then We Tested Vapi
Instead of debating build versus buy in the abstract, I ran a timeboxed spike with Vapi, an off-the-shelf voice agent platform.
We didn't have to hand Bradley over to it.
Our existing pipeline remained the custom LLM endpoint, which meant our search, work-order logic, and logging stayed on our infrastructure.
Vapi handled the voice layer.
Then we compared the two approaches.
Vapi won.
Not because our custom system was bad.
Because for this particular job, the commercial product was better.
That left me with one slightly uncomfortable task.
Write the report.
The Awkward Report
I had built the custom solution.
I knew the architecture.
I knew why we'd made the decisions we'd made.
And I knew how much work had gone into it.
Now I was writing the report recommending that we shelve most of it.
There is a particular kind of temptation in that situation.
Maybe our solution just needs a little more work.
Maybe the comparison isn't quite fair.
Maybe if we improve this piece . . .
Maybe if we optimize that piece . . .
And congratulations, you've just turned sunk cost into a technical strategy.
Evidence Doesn't Care Who Wrote the Code
The job wasn't to prove that I could build a telephony pipeline.
I'd already done that.
The job was to figure out the best way to give Bradley reliable voice capabilities.
Those are very different goals.
Once the evidence showed that the commercial option was the better fit, defending my own code would have meant solving the wrong problem.
So I wrote what the testing showed, including what didn't work.
And we shelved most of the custom build.
Knowing When to Stop Building
Developers get rewarded for making things.
That's the job.
So there's a certain satisfaction in pointing at a complicated system and saying:
I built that.
But good engineering judgment sometimes requires a considerably less satisfying sentence:
We don't need that anymore.
The code can be good.
The architecture can be sound.
The work can have been completely justified when you did it.
And replacing it can still be the right decision.
That's not wasted engineering.
The custom build taught us what the problem actually required. It gave us something real to test against. Without it, "buy" would have been an assumption.
After the spike, it was a decision based on evidence.
And writing the honest report about something you built yourself?
That's not really a technical skill.
It's what keeps technical skill from turning into ego.
Want to know more? See the White Paper here: https://blog.protovate.ai/we-stopped-paying-per-token-and-put-the-models-on-our-own-machine/
Originally published on Protovate.AI
Protovate builds practical AI-powered software for complex, real-world environments. Led by Brian Pollack and a global team with more than 30 years of experience, Protovate helps organizations innovate responsibly, improve efficiency, and turn emerging technology into solutions that deliver measurable impact.
Over the decades, the Protovate team has worked with organizations including NASA, Johnson & Johnson, Microsoft, Walmart, Covidien, Singtel, LG, Yahoo, and Lowe’s.
About the Author
