A few weeks ago a founder we will call Sam was evaluating our product. He runs an e-commerce startup with a twelve-person engineering team. He liked the demo, the pricing made sense to him, and then he said the thing every founder of a small software company eventually hears. His engineers could vibe-code the same thing in a couple of days with an AI assistant, so why would he pay a subscription for it. We build Idlefy, a tool that keeps development virtual machines off by default and starts them on a timed lease, so this question lands on our desk a lot. Our honest answer is that Sam is right about the couple of days and wrong about nearly everything that comes after them. The gap between those two statements is where companies quietly lose real money, and we have watched the build-it-ourselves math fail at enough teams that we think the pattern deserves a proper write-up. This isn't really an article about our product. It is an article about what software actually costs.
A Working Demo Is Not a Product
Let's be fair to the weekend build first, because the progress here is real. With modern AI tools a competent engineer can produce a script that stops VMs on a schedule, posts a message to Slack, and handles the happy path by Sunday night. Five years ago that was a two-week project, and the fact that it is now a weekend is one of the best things to happen to small teams in a long time. The problem is what the demo doesn't contain. It doesn't contain the teammate in another timezone whose machine got shut down in the middle of a deploy, or the exception list that grows out of that incident, or the override button someone needs at 2 a.m. It doesn't contain onboarding for the new hire, permissions for the contractor who should see staging but never production, or an answer for what happens when the script itself goes down. Every one of those is a feature request that arrives within the first month, and every one of them turns your weekend script into a product whether you planned it or not. Buyers see a price tag on commercial software and no price tag on the internal version. That second price tag exists. It just gets mailed to you later.
The Hidden Payroll
The internal tool now needs somewhere to live, and that is the first recurring bill. You need a small VM or a serverless setup to run the scheduler, a database for state, monitoring so you know it is alive, and backups so a redeploy doesn't wipe the exception list. Call it thirty to a hundred dollars a month, which sounds trivial until you notice it is already in the range of many SaaS subscriptions all by itself. The real cost sits on the payroll line. A loaded senior engineer in the US or Western Europe runs fifty to eighty dollars an hour, and an internal tool that people actually depend on consumes a few hours a month at minimum. Dependencies need upgrades, the cloud provider deprecates an API version, someone requests a small feature, something breaks after a Friday deploy. Four hours a month is two or three hundred dollars, which is more than most teams would ever pay for the commercial equivalent, and it comes out of your scarcest resource rather than your most abundant one.
Then the engineer who built it leaves, and we have watched this exact moment play out at more than one company. The tool keeps running, nobody dares touch it, and every request to change it gets politely deferred. Eighteen months later it is quietly turned off, and the machines just run around the clock again like they did before anyone cared.
Here is the napkin math in one place. Swap in your own rates and instance prices and see where you land.
The Boring Parts Are the Product
Once a company grows past three people, the feature list stops being about the core function and starts being about everything around it. Your new DevOps lead wants the tool behind SSO, because one more password floating around a shared vault is how security incidents start. Your first enterprise customer sends a security questionnaire, and suddenly you need an audit trail of who started which machine and when, exportable, with timestamps nobody can edit. Your finance person wants usage broken down by team so the cloud bill can be allocated properly. None of this is hard the way algorithms are hard, but all of it is slow, and it is exactly the work AI assistants help with least, because the difficulty lives in edge cases and organizational detail rather than in the code itself.
The clouds are the other trap. AWS and GCP look similar from a distance and behave differently up close, in how resources are tagged, how permission boundaries work, and what actually happens to disks when an instance stops. A machine type with local NVMe storage loses that data on a stop, and a weekend script that doesn't know this will one day delete a dataset someone needed. We learned these lessons across hundreds of small decisions over years, and so has every serious vendor in every category. That accumulated scar tissue is most of what you are actually buying.
The Price of One Bad Weekend
Here is the scenario that settles the argument for us, and versions of it are the reason Idlefy exists. A team builds its own shutdown scheduler and it works fine for months. Then one Friday evening a cloud credential expires, or an API call starts returning an error code the script has never seen, or someone spins up machines in a region the script never knew about. Nothing alerts anyone, because the tool's entire job is for nothing to happen, so a failure looks exactly like success. A few GPU instances run through the weekend at list prices north of thirty dollars an hour each. By Monday morning the team has burned a couple of thousand dollars, which for a small company is more than a year of fees for the commercial tool they decided not to buy. Run that math with your own instance types before you make the call, because the arithmetic is rarely kind to the weekend build.
The painful part isn't even the one bad weekend. It is that the homegrown tool fails silently and nobody truly owns it, while a vendor has paying customers, an on-call rotation, a status page, and an existential reason to make sure that failure mode never ships. When our product misbehaves, our company's survival is on the line. When your internal script misbehaves, it is a ticket in next sprint's backlog.
How We Decide Now
We sell software, so of course we have an interest here, and you should discount our opinion accordingly. But we buy plenty of software ourselves, and the test we use is the same one we offered Sam. First, is this tool part of what makes your company different, or is it plumbing. We build our own product, obviously, and we buy accounting, support desk, analytics, and email, because being slightly better at any of those wins us nothing. Second, who owns this tool in year two, by name. If the answer is a shrug, the tool is already dead and the money is already spent. Third, what does one failure cost compared with one year of fees. For anything that touches money, security, or compliance, a single bad incident usually outweighs a decade of subscription payments. And fourth, will it ever need SSO, audit trails, or anything a lawyer or an auditor might ask about. If yes, buy it, because that work is invisible, endless, and nobody vibe-codes it for fun on a Saturday.
Vibe coding changed the price of the first eighty percent of any internal tool, and that is worth celebrating. It didn't change the price of the last twenty, and the last twenty is the part your company actually runs on. We don't know yet what Sam will decide. If his weekend build runs flawlessly forever, we will be happy for him. We just wouldn't bet our cloud bill on it.
What was the last tool your team built instead of buying, and would you make the same call today? Tell us in the comments.

