Every month for two years, the same subscription charge hit my card. $150 HubSpot.
And every month, I performed the same quiet ritual that millions of business owners perform with their software subscriptions: I justified it. It’s the system of record. It’s where the contacts live. I’ll use it more next quarter. Everyone has a CRM. This is just the cost of doing business.
Here’s the uncomfortable part. I have spent 25 years in revenue operations and have implemented 8 instances of HubSpot and Salesforce, combined during that time. I know these systems better than the junior reps who sell them. And even I, the guy who should be the power user of power users, was logging in a few times a week to a tool with hundreds of features, using maybe a dozen of them, and paying full freight for the privilege.
The value exchange was never equitable. I knew it. I just accepted it, because that is what we have all been trained to do.
Software was hard to build, so you bought what existed and bent your business around it. You contorted your workflows to fit the platform, then blamed yourself when adoption stalled. The vendor’s answer to low usage was never a better fit. It was another feature, another tier, another price increase, and lately, an AI copilot stapled to the sidebar of a product your team barely uses.
Two years into building with AI, I finally stopped accepting it. I made a decision that would have been irrational for most of my career:
From the beginning, I made an architectural bet: build Mindmoor as if serious companies would run their businesses on it. Not just “good enough” for me but Enterprise-grade, from the schema up.
Not a CRM. Something Built for Me.
Let me be precise about what I did not do, because it matters.
I did not rebuild what exists today. Cloning a bloated platform just gives you a bloated platform you also have to maintain. The entire point was to escape the model where software dictates how you work.
Instead, I started from my actual pain. I run a consulting firm, which means my business is not just a database of contacts. It is a living web of commitments. Deliverables promised to clients. Deliverables a prospect promised to me. Follow-ups buried in email threads, meeting notes, and the back of my brain. Every CRM I have ever used wanted me to do data entry in exchange for a place to store records. None of them cared whether I actually followed through.
So I built a system of follow-through, not a system of record. I call it Mindmoor Commitment Intelligence.
And because I was building for an audience of one, I only built the features with the highest value to how I actually operate:
Zero-form capture. Paste in an email, a scribbled note, a business card, and the record assembles itself, with AI confidence scores on every field so I know what to trust and what to check.
Data enrichment in one click. Instead of cutting and pasting into form fields, click enrich and the Claude-powered enrichment engine does it for me.
A morning brief that does the thinking. Mindmoor reads the signals from my inbox, calendar, and Slack and tells me which commitments are live, which are slipping, and what today actually requires.
An AI assistant on a leash. It drafts the follow-up, preps the action, and then waits. Nothing goes out the door without my confirmation. AI does the work; I keep the judgment.
Structured AI pipeline forecasting. It doesn’t wait for manual stage updates based on a one-sided gut feeling. It uses the commitment logic to recommend when a rep should change deal status based on client engagement and interest.
Every one of those features exists because I needed it, not because a product committee needed something for the release notes. That is what building from the ground up in the AI era actually means. Not faster cloning. Sharper fit.
Built for Enterprise. Not Vibe Coded.
Here is where this stops being a story about a founder’s side project, because a personal tool and a real product are separated by everything you cannot see in a demo.
From the beginning, I made an architectural bet: build Mindmoor as if serious companies would run their businesses on it. Not just “good enough” for me but Enterprise-grade, from the schema up.
That starts at the database. Every instance runs on its own Postgres deployment with row-level security enforced at the data layer, not the application layer. RLS policies mean access control is a property of the database itself: even if application code has a bad day, the data does not. The schema is designed for commitment intelligence natively, with capture confidence, commitment state, and relationship graphs as first-class structures rather than custom fields bolted onto a contacts table.
Authentication follows the same principle. Each client instance runs its own auth system with its own user pool, its own session management, and its own token boundaries. There is no shared identity layer to compromise, because there is no shared anything. AI access is scoped the same way: every instance carries its own dedicated API keys, so one client’s AI usage, context, and spend never touches another’s. Write actions from the AI assistant are gated behind human confirmation, with signed, expiring links for approvals on the go.
Proving the Model: The First Client
For the first version of this story, that architecture was a thesis. Now it is being tested with revenue on the line.
A client saw Mindmoor doing its job in the context of real work. Not a pitch deck. Not a demo environment. The actual tool, visibly useful, in front of someone with the same pain. They wanted it for their organization. We are now building their instance, and the architecture is doing exactly what it was designed to do.
The repo structure is the quiet hero here. The main Mindmoor repository is the single source of truth. Each client runs from their own instance, which means we can build client-specific features rapidly, in their environment, without ever touching the core. If a client-side experiment proves out, we can fold back into the main product. When we ship a global improvement, it flows out to every instance. Custom velocity and platform stability, at the same time. That combination is the thing legacy SaaS has never been able to offer: your requests either die in a feature-request portal or ship to a million customers who did not ask for them.
Just as important: Mindmoor meets companies inside the systems they already live in. The database and auth stack is theirs alone, and the product connects natively to any system you use, so the morning brief and commitment capture run on the software infrastructure the company already uses. No migration trauma. No “switch everything to our suite.” The software adapts to the company, not the other way around.
One client is a proof point, not a victory lap. But it validates the core claim: a product built for one, architected for many, can be fitted to a second business in days, not quarters.
This Is the Future of SaaS
Now zoom out, because this is bigger than my $150 a month.
Right now, every legacy platform on earth is bolting an AI assistant onto the side of a product that was already too bloated, too slow, and too generic. A chatbot summarizing the data nobody entered is not transformation. It is a fresh coat of paint on a building your team already stopped visiting.
You know the pattern because you are living it. Your company pays a six-figure annual bill for a platform with 400 features. Your team uses 12 of them, badly. Adoption is a quarterly initiative with its own steering committee. The workflows do not match how your business actually operates, so people build shadow systems in spreadsheets, and the expensive platform becomes a very elaborate place to store stale data. Then the vendor raises prices.
For decades, we accepted this because there was no alternative. The incumbents’ moat was never their features. It was the cost of replication. AI just drained it.
When a small team can deliver software shaped precisely to your company, your workflows, your language, and your actual use cases, running on infrastructure that belongs only to you, and connected to the systems you already use, the math flips:
Why rent 400 features to use 12, when you can run the 12 built exactly the way your business operates?
Why train your people to think like the software, when the software can now be built to think like your people?
Why wait for a vendor’s roadmap, when your feature request can ship to your instance this week?
I am not arguing every company should rip out their stack tomorrow. I am arguing that the default assumption, that serious software must be bought from a giant and adopted through gritted teeth, is dead. The future of business software looks less like one platform serving a million companies adequately, and more like fitted software serving each company exceptionally, delivered on an architecture built for exactly that.
That is the model I’m proving out with Mindmoor.ai, one isolated instance at a time.
The Takeaway
Two years of $150 charges taught me something the invoice never itemized: the most expensive part of bloated software is not the subscription. It is the workflows you bent, the adoption you chased, and the fit you never got.
The AI era does not just make building easier. It makes fit achievable. Software built for you, from the ground up, with the highest-value features and none of the bloat, on enterprise architecture that treats your data like it is yours. Because it is.
I stopped paying for software that tolerated me. I built software that works for me. And now other companies are starting to run their businesses on that same foundation, fitted to theirs.
The subscription era trained us to ask, “Which platform should we buy?”
The fitted software era asks a better question: “What should software look like when it is built for us?”
I know my answer. It is live, it is secure, it is proving itself with real clients, and it never charges me $150 a month to ignore it.
The future of SaaS is not more features. It is a better fit.
Hey Tony, We found those problems too, and it didn't matter which SaaS solution I looked at. There is nothing so unfulfilling as a recovering programmer who wrote a CRM way back in 1993 before the concept of CRM existed. I used Clarion (a 4GL) running on MSDOS. It tracked the work of multiple sales team members, used dialup to send and receive workload information. the Sales Manager could see yesterdays performance at 9:00am when they clocked in, including those who didn't do the data transfer - A performance flag. It was built for purpose and did its job well. I decided to replace Hubspot with a spreadsheet based system that cost AU$99 and have transformed it to do what we do here. Haven't built the AI Smarts yet. An adventure for another day
I recognised the unused-feature problem when testing assistants with colleagues. Removing steps they did not want was more useful than adding another capability.