I Built a Fintech Startup in 2020. What AI Actually Changed

In 2020 I launched a fintech startup — a stock-screening app with a React Native mobile client and a React web app on top of a Node.js API and MongoDB, plus a Python layer running PySpark, NumPy, and TensorFlow to crunch the data. It ran for over three years and grew past two thousand users. This year I built a stock screener again — QuantScreen — this time with AI agents doing most of the typing. Same domain, two eras of engineering, six years apart. The honest comparison is more useful than the hype pointing in either direction: one part of the job got dramatically cheaper, and the part that actually decides whether you ship didn’t move a millimetre.

One caveat up front, because this whole publication runs on it: the numbers above are ones I stand behind, but I’m not going to invent precise build timelines from a six-year-old project to make the comparison land cleaner. What I can compare honestly is the shape of the work — and the shape changed in one specific, measurable place.

How much faster is it to build an app prototype with AI agents?

For the prototype specifically: dramatically. Not “twenty percent more productive” faster — “the first two weeks now take an afternoon” faster.

The starting line moved. In 2020 a new app began at an empty repository, and getting from there to anything running on real data was a fixed tax you paid before the interesting work started. Today an agent gets you to a working skeleton on real data in an afternoon. That’s a genuine, load-bearing change, and I don’t want to undersell it to sound measured — for validating whether an idea is worth pursuing at all, it’s a gift I’d have traded a lot for back then.

What used to eat the first month?

The opening stretch had nothing to do with the product and everything to do with surface area. The system was a handful of moving parts — the React Native app, the React web client, the Node API, MongoDB, and the Python pipeline behind them — and every seam between them was hand-built. The API client and its endpoints. A request and response model for each call, kept in sync with two backends by hand whenever anything changed. Auth, session handling, secure token storage. Standing up a Spark job and a TensorFlow loop just to get numbers out the far end was its own week of work. None of it was the product. All of it stood between me and the product.

And the “AI help” available in 2020 was autocomplete and Stack Overflow. GitHub Copilot’s first technical preview didn’t arrive until mid-2021; anything you’d call an agent is years after that. So the boilerplate got written the only way it could be — one line at a time, by a person who’d rather be solving the actual problem.

That entire opening tax is what agents collapsed. QuantScreen is deliberately smaller — one monorepo, two languages, a single SQLite file where the 2020 build had MongoDB and a Spark pipeline — and the parts that do exist got scaffolded, typed straight from a schema, and wired end-to-end in hours instead of weeks. The boilerplate didn’t get easier to write. It stopped needing to be written by me.

There’s a second-order effect worth naming. When infrastructure was expensive to stand up, you built big up front to amortize the cost — a Spark pipeline you might grow into, an ML stack you’d own end-to-end. When setup is nearly free, you build the smallest thing that works and add scale only when something actually strains: QuantScreen runs the whole S&P 500 through one Python process and SQLite, no cluster in sight. That isn’t the 2020 stack being wrong. Given what setup cost back then, reaching for the big capable architecture was often the rational move. The economics just changed underneath the decision.

So can anyone build a fintech app in a weekend now?

No — and this is exactly where the hype quietly swaps “prototype” for “product” and hopes you don’t check the substitution.

A weekend prototype and a shippable product are separated by precisely the work agents didn’t touch. Deciding what’s worth building at all. Whether you’re even allowed to use your data source commercially — the question that killed my own monetization plan in one afternoon. Data correctness under restatements and corporate actions, which is most of the real engineering in a screener. And whether you can trust the output enough to put money behind it — the reason I run an adversarial review workflow over everything the agents produce.

Agents moved the starting line, not the finish line. The distance between the two is the same as it ever was. You just reach the hard problems sooner now, which is progress of a kind — as long as you don’t mistake arriving at them for having solved them.

What’s the difference between a prototype and a product?

In fintech, mostly the data — and this is where a personal instrument and a real product stop being the same thing. QuantScreen runs on yfinance, which pulls Yahoo data that’s licensed for personal use only. That’s fine for a tool I use alone. It’s disqualifying the moment money or ads enter, on both the licensing and the data-quality axes.

For anything production-bound you swap that feed for a properly licensed one. I built for that swap deliberately — the vendor sits behind a single adapter, so replacing it is a one-module change, not a rewrite. But choosing the feed is its own research project: coverage, point-in-time history, redistribution rights, and price all move independently. I’ve since done that comparison across the main vendors, so if you’re at that decision, reach out and I’ll point you at what actually fits your use case and budget rather than what markets best.

Verdict

• Worked: prototyping genuinely got an order of magnitude faster, and that’s not marketing — the weeks that used to disappear into boilerplate now don’t. For testing whether an idea has legs before committing to it, this changes the economics honestly.
• Cost: the speed is seductive in a dangerous way. A weekend prototype feels like a product and is nowhere near one, and faster building also means faster accumulation of decisions nobody reviewed. The cheaper the code gets, the more the discipline around it matters.
• Blocked: the startup this post compares against ran over three years and past two thousand users, and whatever finally stopped it, “we couldn’t build fast enough” was never on the list. That’s the pattern. Six years later I can build ten times faster and the failure modes are identical — wrong thing, wrong market, wrong data rights. AI moved the one constraint that was never really the binding one.

This is the fourth in a set on building QuantScreen: the architecture, the agentic workflow, and the licence research that rules out selling it.