The short version: I built a complete, bank-connected financial operating system as a solo developer — part-time, as a side project, over six months. Live bank connections, automated reconciliation, invoicing, OCR document scanning, inventory, multi-tenant security, the full surface. A funded team would budget 12 to 18 months and somewhere near $1.5M for the same scope. The gap between those numbers is the whole story — and there's a catch in it most people miss.
I'm a software engineer who has also sat on the other side of the table — as an investor deciding whether a piece of software was worth funding, and what it should cost to build.
So when I say the math has broken, I'm not theorizing. I watched it break on my own screen.
The product is Finintra. It's a financial operating system for small and mid-sized businesses — one place where the budget, the bank transactions, the supplier bills, the invoices, the inventory, and the team all live together and reconcile themselves. Without a tool like this, that work is smeared across five apps that don't talk to each other, and month-end becomes a two-day reconstruction project.
What it does, plainly:
- —Connects to live bank accounts through Plaid and Lean, so transactions flow in automatically instead of being exported and pasted by hand.
- —Scans supplier bills with OCR — including a "paste from WhatsApp" path, because that's how bills actually arrive.
- —Matches payments against bills automatically, so reconciliation stops being human glue.
- —Sends invoices, tracks what's owed, manages inventory and subscriptions, shows budget-versus-actual in color.
- —Runs multi-tenant with row-level security, role-based access, and an audit trail — built Arabic-first and RTL-first, not patched on later.
This is not a prototype or a weekend demo. It's a complete, working financial platform — and I built it on the side, in evenings and gaps, around running companies, over roughly six months. I want to be precise about what that means, because the precision is the whole point.
How long does it take to build a SaaS this size with AI?
Six months, part-time. A side project — not a full-time sprint, not a funded team, not a single all-nighter. Built in the margins of a working life.
Sit with that for a second. A financial platform with live bank integrations and multi-tenant security, to a complete and working state, built by one person who was never working on it full-time. The reason that's possible at all comes down to the second number.
What would this have cost a team to build?
By a conservative replacement-cost estimate — what you'd pay to hire people to build the same feature scope — this lands between $1.2M and $2.2M. Call it $1.5M in the middle.
Let me be precise, because I've watched founders get torched for sloppy claims. I am not saying Finintra is worth $1.5M on a balance sheet — valuation is a different conversation. And I am not claiming I personally did $1.5M of labor. Here's the honest distinction most "I built it solo" posts skip:
I matched the feature scope a funded team budgets 12–18 months for. What I have not yet done is the back half of that budget — the hardening, compliance, scale testing, and support infrastructure that turns a working product into one that survives a thousand customers and a security audit.
That's the catch, and it's the actual insight: the building collapsed. The operating didn't. Producing a complete, working feature surface is now radically cheap. Making it bulletproof at scale is still expensive, still slow, still mostly human. Anyone who tells you AI erased both halves is selling something.
One more honesty check, because the sharp readers are already thinking it: a team building this today, with AI, wouldn't spend $1.5M either. True. The floor dropped for everyone. The point isn't that I beat a team — it's that the floor dropped far enough that a single person, working part-time, can now stand on it. Here's the team you'd have budgeted in 2023, before AI coding tools did real work:
What you'd needThe old estimatePeople6–8: two backend, two frontend, a designer, a PM, a QA engineer, fractional DevOpsTime12–18 monthsFully loaded cost~$1.2M–$2.2M
The integrations and the data layer are where the hidden cost lives — and, not coincidentally, where AI helped me least.
Where AI fought me
I want to kill the impression that this was frictionless, because it wasn't — and the friction is the most useful thing in this post.
AI was extraordinary at the broad surface: scaffolding features, grinding through internationalization, writing the boilerplate that used to eat days. But on the parts that actually matter for a financial product, it was confidently wrong often enough that I stopped trusting the smooth answer.
Here's the one that cost me the most time. The same number — a daily transaction total — was showing up differently in two places: the daily transaction calculation and the analytics dashboard. Both numbers looked correct. Each was internally consistent, each had plausible logic behind it, and that is exactly what made it so slow to find. Nothing threw an error. There was no crash, no red flag — just two confident answers, quietly disagreeing.
The root cause was that the metric had been implemented twice, independently, with no single source of truth — and the two versions disagreed on two subtle things. First, whether records flagged as disabled in an organization's settings should count: the analytics path included them, the daily calculation excluded them, so analytics always ran higher. Second, where a day actually begins — the two paths bucketed transactions around the midnight boundary differently, so anything near midnight fell on different days.
No automated test was ever going to catch that. The only thing that caught it was refusing to accept two numbers that should have been identical. I traced both paths back to their data source, compared a single day row by row, found the exact point they diverged, collapsed the two into one canonical function, and added a reconciliation test that now fails the instant those numbers ever drift apart again.
That's the real shape of building this way. AI will happily hand you two correct-looking implementations of the same metric and never once mention that they'll disagree. The typing was free. Knowing that two plausible numbers couldn't both be right — and caring enough to chase down why — was not. That is judgment, and judgment is the part AI does not do for you.
Can one person really build enterprise software with AI?
Yes — but not because AI types fast. Because it removes the wall where one person's bandwidth becomes the product's ceiling.
AI stood in for the teammates I didn't have. It held architecture in its head while I was deep in another problem. It scaffolded entire features. It flagged things I'd have missed. Not a flawless team — see above — but good enough that I never stalled waiting for capacity.
That changes two things that simply weren't true a few years ago.
The solo builder is back, at real depth. The garage-era founder who shipped something alone faded as software got heavier and every serious product demanded multiple specialist teams. The minimum viable team kept growing. AI shrank it again. One technically literate person with sound judgment can now carry an entire product to a complete, working state.
The leverage moved to judgment. I wasn't faster because more code got written per hour. I was faster because I could decide what to build, in what order, with what tradeoffs — and act immediately, with no handoff and no waiting. The bottleneck was never keystrokes. It was the distance between knowing what to do and being able to do it. That distance collapsed. What's left — deciding what's right, and catching what's quietly wrong — is harder and more valuable than ever.
So what should you do about it?
If you build: stop waiting for a co-founder to own the backend or a sprint to begin. The tools to build the thing in your head exist now. Learn AI the way a good engineer learns any infrastructure — until you know exactly where it'll hand you something confidently wrong. That gap, between what it generates and what your judgment knows is right, is where your value now lives.
If you manage builders: "more engineers equals more output" is quietly breaking. One engineer with real AI fluency out-produces three without it. Not a layoff argument — a leverage one. Your highest-leverage person is the one who already stopped working the old way.
If you're building a company: the capital and headcount needed to reach something real have dropped hard. A solo founder with AI and a few months isn't building a throwaway MVP anymore — they might be building the product. That reshapes milestones, dilution, and when you actually need outside money.
Where this leaves you
I'm not writing this to wave a project around. I'm writing it because I spent six months proving, on a real product with real bank connections, that the old rules about who can build what no longer hold — and learning exactly where those rules still bite.
My last piece asked what kind of professional you are when the easy parts of your job disappear. Here's the sharper version: what would you build if the hard parts got cheap — and would you have the judgment to handle the parts that didn't?
Because that's the real divide now. Not between people who can build and people who can't — almost anyone can build now. The divide is between people whose judgment is good enough to be trusted with the half that AI can't do, and people who mistake a smooth-looking answer for a correct one.
The tools are here. The cost has fallen through the floor. The only question left is whether your judgment is ready for what remains.
Finintra isn't officially launched yet. If you run an SMB drowning in disconnected finance tools — or you just want to see what a solo-built financial OS looks like under the hood — take a look here.
FAQ
Can one person build enterprise software with AI in 2026? Yes. With AI handling code generation, feature scaffolding, and specialist work like internationalization, a single skilled developer can build a complete, working financial platform — multi-tenant architecture, row-level security, audit trails — that previously required a team of six to eight. The limit is no longer feature scope; it's the hardening, compliance, and scale work that AI doesn't do for you.
How long does it take to build a SaaS with AI? It depends on scope and how you work. As a concrete data point: a financial operating system with live bank integrations, OCR, automated reconciliation, and multi-tenant security was built by one person, part-time, over roughly six months — alongside a full working life, not as a full-time effort.
How much does it cost to build a fintech SaaS the traditional way? A comparable bank-connected financial platform built by a 6-to-8-person team would run roughly $1.2M to $2.2M fully loaded over 12 to 18 months, with bank integrations, OCR tuning, and secure multi-tenancy driving most of the hidden cost. A team using AI today would build it for far less — the floor has dropped for everyone.
Is AI replacing software development teams? Not entirely. Teams still matter for distribution, commercial relationships, accountability, and the production hardening that turns a working product into a reliable one. But AI has collapsed the minimum team size needed to build a product of real depth. The leverage now sits with individuals who pair sound judgment with AI fluency.
What's the most important skill for building with AI? Judgment. AI closes the gap between knowing what to build and being able to build it, but it produces confident, wrong answers on the parts that carry consequences — duplicated metric logic that quietly disagrees, security boundaries, edge cases. Knowing when to trust it and when to override it is the skill that matters most.
Obaid Ghafoori is a software engineer and investor working at the intersection of deep technology and business — from engineering at ASML, the company behind the world's most advanced semiconductor lithography, to founding and building technology products. Finintra is his latest.