02 / business systems · Software that runs your business
Developer for booking systems, online payments and customer accounts
Bookings, payments, logins and customer accounts that work every time, even when many people use them at once.
- Three live products, each serving many businesses
- Driving schools, yacht charter, study abroad
- Built Gradsy end to end, on my own

what I build
The parts that must never fail.
Your customers never see this half — until it breaks. I make sure it doesn't.
booking systems
appointments that can never be double-booked
online payments
subscriptions and invoices that charge the right amount, once
logins and user roles
everyone sees only what they are allowed to see
SaaS platforms
one product sold to many businesses, each with its own private space
multi-branch apps
many offices or locations on one system, with their data kept apart
automated tasks
reminders, reports and emails that run on their own
connections to other tools
your app talking to payment, email and calendar services
APIs
one reliable connection your website and mobile app can both use

how it goes
Rules first, then the build.
I start by asking what must never go wrong. That answer shapes everything else.
set the rules
what must never happen — a double booking, a mixed-up account, a card charged twice
design
a structure that makes those mistakes impossible, before any feature is built
build
the logic, logins and automatic tasks, each checked against those rules
launch and run
deployed on reliable cloud hosting, with updates that are routine rather than risky

why it matters
Your rules, enforced every time.
Software that checks a rule can forget to. Software built around the rule can't.
- no double bookings
- if two people grab the same slot in the same second, only one gets it.
- charged exactly once
- a repeated payment message never turns into a repeated charge.
- private by design
- each customer's data is kept apart at the core, not by a line of code someone might forget.
- clear permissions
- who can do what is decided in one place, and easy to check.
- safe updates
- a bad update can be undone quickly instead of becoming an emergency.
- written down
- documented as it is built, so nothing lives only in one person's head.
sound familiar?
You have probably said one of these.

“Two customers booked the same slot, and we had to refund one.”
The system checked the slot was free, then saved, and a second booking slipped in between. I build it so a double booking simply cannot be saved.
“A customer was charged twice.”
Payment providers sometimes send the same message twice. Everything I build expects that, so a repeat never becomes a second charge.
“We now serve several businesses and worry their data could mix.”
I separate each customer's data at the core of the system, so one client can never see another's.
“Only one person understands our system, and none of it is written down.”
I document as I build — how it works and why. I have been that one person, and it is a risky place for a business.
“Nobody on the team wants the boring but critical work.”
Permissions, billing edge cases, the task that runs at 3am and has to be right. That is the work I take on.
- Node.js
- NestJS
- PostgreSQL
- AWS
I build the screens on top as well, so you deal with one person from the database to the button.
how I build it
I start with the rules that must never be broken. Two people should never book the same slot. A customer should never be charged twice. One business should never see another's data.
Then I build the system so those mistakes cannot happen, rather than hoping the code remembers to check. If two people click "book" in the same second, the database itself lets only one through, and the other is told the slot has gone.
Automatic tasks like reminders, payments and reports are written so that running twice does no harm. Payment providers sometimes send the same message twice, and your customer is still charged once.
Permissions live in one place, so "who is allowed to do this?" has one clear answer. Updates can be rolled back cleanly if something goes wrong. And I document as I go, so the system never depends on one person's memory.
when a project needs more than me
I set up and run the hosting most products need. If yours needs heavy infrastructure work, I bring in senior engineers I already work with. The core system stays with me, and you still deal with one person.
working together
You bring it. I handle it. You get it back better.
you bring
- your product, or the process you run by hand today
- the rules that must never be broken
- whoever answers the complaint when one is
I handle
- planning how your data is stored
- logins, and who can see what
- bookings, payments and invoices
- automatic emails, reminders and reports
- connections to the other tools you use
- hosting and safe updates
you get
- your code, owned by you from day one
- written documentation, not a promise of it
- a system that enforces your rules on its own

Something in your business that must never go wrong?
Thirty minutes on what you run and what has gone wrong with it. I'll tell you how I would fix it, and whether I'm the right person to.
