Who this is for: Business owners, directors and IT leads deciding how their next system should be built, now that AI writes much of the code. You don't need to be an engineer to follow this. Technical notes are marked and can be skipped.
We build and run production software for clients, including ERP, LMS and POS systems, with AI models like Claude and Gemini every day. After years of this work, the technology that serves our clients best is mostly from 1995: plain web pages, simple styling and SQL databases, running on one small server per client.
This post explains why, and what it means for the cost, speed and lifespan of the systems we deliver.
Why the technology underneath matters more now
When people pick a software partner, they usually ask about features, price and timeline. Few ask what the system is built on. That used to be reasonable, since it was the engineers' problem.
With AI writing much of the code, it is now a business question. The technology underneath, the "stack", decides three things you will feel directly:
- How fast changes arrive. Some stacks let an AI produce working code on the first attempt. Others make it stumble for hours on setup problems unrelated to your business.
- What it costs to run. A complex stack needs a cluster of cloud services, each with its own monthly bill. A simple one runs on a single small server.
- How long it lasts. Every extra component is something that can be abandoned by its makers or break on the next upgrade, and someone has to pay to fix it.
The popular tools were built for Google-sized teams
Most modern web software is built with large frameworks (React, Next.js and similar). They were created at companies like Meta and Google to solve a specific problem: keeping hundreds of engineers from breaking each other's work. At that size, the extra layers and rules are worth it.
Our projects don't look like that. A typical Alpha Bits team is a project manager, a fullstack developer and QA, with AI agents doing most of the typing. In 2015 the same kind of ERP project took us 20 to 25 engineers.
For a small team working with AI, those big-company layers get in the way. More often than not, we saw AI agents spend more time fixing the framework's own setup than building what the client asked for. Every hour of that is an hour the client pays for without getting a feature.
Why we moved back to one application
The same big-company thinking shaped the server side. "Microservices" split one system into many small services, each with its own code, its own database and its own deployment, talking to each other over the network. It lets large organisations give each team its own piece to own.
We built systems this way for years, including a superapp platform running on Kubernetes in the cloud. For an SME enterprise system, the overhead is far larger than the benefit:
- Every service is something to run. Each one needs its own deployment, monitoring, logs, security updates and often its own database. Ten services means ten of everything.
- One change touches several services. Adding a field to an order can mean changing the order service, the invoice service and the reporting service, then releasing them in the right order. A small change becomes a coordinated release.
- Problems are harder to find. When a report is wrong, the cause can sit in any service or in the network between them. Tracing it takes specialist tools and specialist people.
- The cloud bill grows with the number of services, even when the number of users doesn't.
So we went back to a monolith: one application, one database and one deployment per client. Inside, it is still organised into clear modules (CRM, orders, LMS, POS, HR), but they run as a single program on a single server.
The gain shows up most in development time. A change is one edit, one test run and one release. AI agents do especially well here, because the whole system sits in one place they can read end to end, so they see every part a change affects before they make it.
AI has read 30 years of 1995 technology
AI models learn from public code. They have seen thirty years of basic web pages (HTML), styling (CSS) and database queries (SQL), far more than any framework released in the last few years.
In our day-to-day work, the difference is clear. Ask an AI for a plain web form or a sales report query and the first version usually works. Ask it to do the same inside a heavy framework, and it often mixes up instructions from different versions of that framework and gets stuck.
Technical note: we write server-rendered HTML with Hono, add interactivity with HTMX and Alpine.js only where a page needs it, and run TypeScript directly on Bun. Drizzle sits as a thin typed layer over SQLite, and we write plain SQL when a query matters.
The AI's memory is a set of plain documents
To keep AI agents consistent across weeks of work, much of the industry now builds complex "memory" systems with specialised databases. We don't.
Each of our projects keeps its rules and history in a few plain text documents stored with the code:
- a short rulebook: what the system is built on, what must never change, how to check the work;
- a progress note: what is in progress right now, so the next work session picks up where the last one stopped;
- a decision log: every important technical decision and the reason for it. This website's log has dozens of entries.
Any AI model can read these in seconds. When we switch between Claude and Gemini, the new model reads the same documents and carries on. For a client, this means the knowledge about your system is written down inside your system, where anyone can read it. If you ever change vendors, the next team gets the same rulebook.
This is the idea behind Konductor, the open-source workflow we use on every project.
One file holds the business data
FoxPro, a popular business database in the 90s, kept data in simple files on one computer. A single machine ran the whole system: no database server, no network setup, no specialist to keep it alive.
The industry then spent twenty-five years moving the other way, splitting systems across many cloud services. Most business systems never needed that.
Today we use SQLite, which brings back the FoxPro approach on modern hardware. Each client's data lives in one file on their own server. Reports run fast because nothing has to travel over a network, and a full backup is a copy of that file. For a company of 15 to 200 people running sales, training, inventory and accounting, it is plenty.
Our AI Lean Stack in production
This is the setup behind our ERP core and every module built on it (LMS, POS, sourcing, HR, tax), and behind this website:
| What it does | The common way | What we run |
| The screens people use | Large JavaScript framework (React, Next.js) | Plain web pages, made interactive where needed (HTMX, Alpine.js) |
| The application | Many services in containers | One application (Bun + Hono) |
| The business data | Managed cloud database with a monthly bill | One SQLite file per client |
| The AI's memory | Specialised AI memory database | Plain documents stored with the code |
| Where it runs | A cloud cluster (Kubernetes) | One server per client, 4 cores and 8 GB of memory |
Each client gets their own copy of the code, their own database and their own server. alphabits.team itself has run on a single Hetzner server for years. Later in this series we'll show what moving off the big cloud providers saved us and our clients.
What it means for delivery
A successful enterprise deployment with us takes 3 to 6 months from kickoff to full rollout, with results the team can see and use within the first 6 weeks.
With fewer places for AI work to get stuck, more of the budget goes into your business processes.
Faster delivery, and more reliable too
A fair question at this point: if we ship this much faster, are we cutting corners on quality?
We test far more than we used to. AI writes test code as readily as it writes features, so every change now comes with tests at every level: unit tests for individual calculations, integration tests for how modules work together, and end-to-end tests that click through the web and mobile screens the way a real user would. Compared with our projects before AI, we run around 100 times more test cases.
The simple stack is what makes that practical. On the old framework-heavy projects, a full test run could take hours, so teams ran it rarely and skipped it under deadline pressure. Set up the right way, our full suite finishes in seconds to about a minute. When testing costs a minute, we run it on every change.
The kind of problem we find has changed as well. Flaky screens and clumsy UI bugs used to take up most of our QA time. Today, what testing surfaces is mostly gaps in the business rules: a discount case, an approval step or an exception nobody mentioned in the early discussions. Those are the problems worth spending time on, and they get settled with the client before go-live.
Technical note: tests run on bun:test in parallel across CPU cores, with browser tests on a headless WebView. The type check and full suite run automatically before every release.
Will it still work in 20 years?
Every component a system depends on is a bet that someone will keep maintaining it. When the bet fails, you pay for a rewrite.
A web page written in 1995 still opens in every browser today. A database query written in 1995 still runs. We expect what we build in 2026 to still work in 2046, and we can't say that about any of the large frameworks we have used.
Questions to ask your software partner
Whether you work with us or someone else, ask these before you sign:
- What is the system built on, and how many separate services does it need to run? Fewer is cheaper and easier to keep running.
- What will hosting cost per month after any free cloud credits run out? Ask for the number in writing.
- Where is the knowledge about my system written down? If the answer is "in our team", you are locked in.
- When will I see something working? For us the answer is within 6 weeks. Be careful with anyone who can't name a date.
This post is the foundation for our Built in Production series: how we work with AI, the ERP core we built this way, and why we run it all on our own servers. If you're planning a system and want a second opinion on how it should be built, send us a message.