Your software live in weeks, not months.
Fifteen years of software architecture, AI-accelerated delivery. One engineer, from the first sketch to production.
15 years in production
A decade at IBM Research Zürich, then four years running the API behind a multichain DeFi protocol, on-call included.
Shipped inside an IBM product
Topic-level encryption and key rotation for Apache Kafka, designed and written in Go. IBM took it into the Event Streams product.
No agency layer
You talk to the person writing the code. No account manager, no handover, no billed meetings. Swiss GmbH, invoiced in CHF.
Built and running
Each of these went from a first conversation to software people use. Client work stays unnamed on request.
Workshop planner
A Zürich coffee-equipment service shop planned repairs on paper and could not answer when a machine would be ready. Now intake, mechanic load, parts waiting, and pickup sit on one board that answers it.
- React
- Fastify
- Postgres
Beanbook
Photograph a coffee bag and the label is read for you, no typing. Every bean keeps its brew recipes, and the whole collection stays on the phone.
- Expo
- vision model
Mein Trainingsplan
A half-marathon plan that keeps itself up to date: tick a session off or import the file from the watch, while XP, streaks, and badges carry you through the dull weeks. The finish-time projection comes out of your own runs and nothing leaves the phone.
- Expo
- Garmin FIT
Why this ships faster
You have a process that runs on paper, spreadsheets, or a tool that was never meant for it. The agency quote came back at two quarters and a number with too many digits. The cheap freelancer built a prototype that died the week it met real data. So the problem stays where it is, and everyone keeps working around it.
AI writes most of the code now. What it does not do is decide what to build, model the data so it survives the second year, or spot the failure that only shows up under real load. That judgment is what fifteen years of architecture buys. Put the two together and you get production software in weeks, at a price that used to buy a specification document.
Scope in a call
Thirty minutes to work out what the software actually has to do. You get the scope, an estimate, and a realistic date in writing before anything is built.
Prototype in days
A clickable version in your hands in the first week. You use it, you tell me what is wrong, and the correction happens while it is still cheap.
Ship and hand over
Deployed to production on your own accounts, with the repository, the documentation, and the source in your name. Nothing stays locked to me.
Three ways to work together
Agreed-scope build
An agreed product on an agreed date. Most builds run four to eight weeks from the first call to something running in production.
- Scope and price agreed before the first line of code
- Weekly build you can open and use yourself
- Deployed on your accounts, source and repository in your name
Written estimate after the first call
Prototype sprint
One week, one working prototype. Enough to test the idea with real users, or to put in front of a board before committing a budget.
Ongoing partner
A monthly arrangement for changes, new features, and keeping what is live healthy. Useful once the first version is in real hands.
Questions people ask first
Less than an agency and less than another year of the problem. The number depends on scope, so you get a written estimate after the first call, before anything is built. If something during the build would push it, you hear that before it happens, not on the invoice.
Tell me what you want built.
A few lines about the problem is enough. You get a straight answer on whether it is worth building and what it would cost, not a sales sequence.
Opens an email with three questions already filled in. You get a reply within one working day.
pascal@moontravel.ch