The Pub Prototype: Coding a SaaS on a Smartphone
Published on
The Pizza Problem
Most technological leaps in my life seem to originate from a deeply trivial annoyance. In this case, it was a debate in a pub about pizza.
A few friends and I were trying to establish, once and for all, the definitive ranking of local pizza places. It quickly became clear that simply yelling our preferences at each other wasn't producing a statistically rigorous result. What we needed was a proper tournament format - specifically, the Elo rating system.
Originally invented by Arpad Elo to rank chess players, the Elo system is brilliant for subjective debates. Instead of trying to score every pizza out of ten, you just do head-to-head matchups. Pizza A vs Pizza B. The winner takes points from the loser, and over enough matchups, a highly accurate, mathematically sound leaderboard emerges.
We searched the App Store and the web for a quick tool to do this. Everything we found either required creating an account, had a terrible UI, or was buried under layers of ads. We didn't want to write it down on napkins. So, I wondered just how difficult it would be to build our own bespoke application right there at the table, using an AI coding assistant to do the heavy lifting.
The Zero-Backend Build
I decided to keep the architecture as brutally simple as possible. It didn't need a backend database, user accounts, or a server. The entire thing could run purely in the browser using HTML, CSS, and JavaScript, with the ranking data saved locally to the user's device using localStorage.
Using an LLM on my phone, I prompted it to generate the application. I gave it the requirements: a clean interface, the maths logic for the Elo algorithm, and the local storage setup. Within minutes, it had spat out the working code.
The deployment process was exactly the same as it has always been - buying a domain and hooking it up to a basic static hosting provider. But the fact that I was able to define the logic, generate the code, and deploy a live, globally accessible web app entirely from a 6-inch screen while waiting for another round of drinks is genuinely staggering.
If you want to see the result of this highly scientific pub experiment, it is live right now at https://rankit.info/.
Validating the SaaSpocalypse
A few months ago, I wrote about the trillion-dollar market wipeout triggered by Anthropic releasing a simple text file, and how the "proprietary" moats of many software companies are effectively non-existent. Building RankIt validated that theory on a micro-scale.
If a moderately tech-savvy person can build a bespoke, fully functional utility app on their phone in under an hour, the barrier to entry for basic software has officially collapsed to zero.
There are, of course, massive caveats. RankIt is a stateless, client-side application. The moment you decide to build something more complex - an app that requires user authentication, relational databases, middleware APIs, or the handling of sensitive personal data - the game changes completely.
Relying entirely on an AI agent to architect your backend security is a recipe for disaster. You would not want to trust an LLM hallucination to properly salt and hash your users' passwords or ensure your data pipeline is fully compliant with GDPR. Human engineers are still very much required to build the reinforced concrete foundations of secure, enterprise-grade software.
The Capital Stack Conundrum
However, this rapid prototyping capability shouldn't just terrify incumbent software vendors; it should send a shiver up the entire financial capital stack.
For the last decade, the assumption across the board has been that software has high switching costs and wide defensive moats. At the early stage, you have Venture Capital and UK SEIS (Seed Enterprise Investment Scheme) funds pouring millions into startups whose entire business model is just a slick UI wrapped around a basic database. Further up the chain, the shadow banking sector and private credit markets have loaded massive debt onto Private Equity buyouts of mid-tier B2B SaaS companies, banking entirely on the sticky nature of "recurring revenue." Even the public markets have priced enterprise software stocks for a reality that might no longer exist.
The RankIt experiment suggests those moats are drying up. If a business is paying £50,000 a year for a clunky, mid-tier SaaS tool to handle a specific internal workflow, and an internal business analyst can now use an AI agent to build a bespoke, perfectly tailored replacement in a single weekend, that recurring revenue vanishes.
When the cost of creating software plummets to near-zero, the value of owning mediocre software plummets with it. The debt holding those massive buyouts together relies on customers having no cheaper alternatives. As it turns out, if you know what yo're doing, the cheaper alternative solution is now sitting in everyone's pocket.
The Infinite Spaghetti Loop
But this utopian vision of everyone building their own bespoke software ignores the brutal reality of what happens the day after deployment: maintenance.
As someone who spends a lot of time looking at enterprise architecture, the immediate concern is the sheer volume of technical debt this will create. We are entering an era where non-technical founders and middle managers are deploying code they fundamentally do not understand. If a database query fails, or a critical security vulnerability is found in an NPM package, they won't know how to fix it. They will just ask the AI to "make it work," resulting in layer upon layer of duct-tape fixes - a sprawling, undocumented mess of digital spaghetti.
Will human developers eventually have to be brought in at exorbitant day rates to untangle these massive, AI-generated Gordian knots?
Possibly not. And that is the truly wild part.
A human developer will open a million-line codebase of AI-generated spaghetti, cry, and immediately quit. But an AI coding agent doesn't get bored. It doesn't get frustrated. It doesn't care if the architecture is ugly. It can ingest the entire sprawling mess, hold the whole context in its massive memory, and instantly trace a bug through fifty layers of poorly optimized logic.
We might simply reach a point where software becomes a black box - written by AI, maintained by AI, and continually refactored by AI, far beyond the limits of human comprehension. It leaves us with a fascinating, slightly terrifying reality: we are building a world that is incredibly easy to create, but one that we no longer actually understand.