Custom software
Software that actually ships, and scales.
Custom web applications, production APIs, SaaS products and enterprise systems — scoped, architected, built and deployed, with documentation, tests and code you can hand to somebody else.
Our stack
Built on proven, modern technology.
The technologies strong engineering teams rely on now — not the ones we were comfortable with five years ago.
- React
- Next.js
- TypeScript
- Vue.js
- Tailwind CSS
- Node.js
- Python
- FastAPI
- Express
- GraphQL
- PostgreSQL
- MongoDB
- Redis
- Supabase
- S3 / R2
- Docker
- AWS
- GCP
- Vercel
- GitHub Actions
What we build
Software for the process no product on the market fits.
From a single-feature web app to a full platform. Every project ships with documentation, tests, and a handover that assumes we might not be the ones maintaining it.
Custom web applications
The internal tool, customer portal or operational system your business runs on, built around your actual process rather than bent to fit somebody else’s product.
The spreadsheet holding the business together retires
APIs & integrations
REST and GraphQL APIs, plus the middleware that makes systems which were never designed to talk to each other behave as one.
Data stops being re-keyed between tools
SaaS product development
Multi-tenant products with authentication, billing, roles and permissions built correctly from the start — because retrofitting tenancy is the expensive way to learn about it.
A product you can sell, not a prototype
System integration & middleware
Connecting existing platforms — CRM, accounting, inventory, logistics — so a change in one is reflected everywhere without anyone copying it across.
One version of the truth, across every tool
Database design
Schema design, migration strategy, indexing and query performance work — the layer that decides whether the application is still fast in two years.
Performance that holds as the data grows
DevOps & cloud
Containerisation, CI/CD pipelines, infrastructure-as-code, monitoring and backups. Deploying should be boring.
Releases that stop being an event
Software + AI
Both halves, under one roof.
Most AI projects fail at the boundary rather than the model: the intelligence works, and then it has nowhere to live. It needs an interface people will actually use, a database that holds the results, permissions that decide who sees what, and a deployment somebody maintains.
Because we build the software as well as the AI, that boundary is not a handover between two suppliers pointing at each other. It is one system, scoped and owned in one place.
- AI capability designed into the architecture, not bolted on after
- One team accountable for the model and the application around it
- Fixed-price scope agreed before the build starts
- Documentation and tests, so the code outlives the engagement
How we work
What exists at the end of each stage.
01
Discovery & scope
We map the process the software has to serve, agree what is in and explicitly out, and produce a fixed price. You keep the scope document either way.
02
Architecture
Data model, integrations, infrastructure and the decisions that are expensive to reverse — written down and agreed before anything is built on top of them.
03
Build & review
Delivered in working increments you can use and react to, rather than one reveal at the end when changing direction is most expensive.
04
Deploy & hand over
Live, monitored, backed up, documented. Handover assumes somebody else may maintain it — because eventually somebody else might.
FAQ
Common questions.
Do we own the code?
Yes, outright, in your own repository. Documentation and tests come with it. Nothing is held hostage to keep you on a retainer.
How is it priced?
Fixed price against an agreed scope, produced during discovery. If the scope changes mid-build we price the change before doing it, rather than after.
What if we already have a development team?
Then we work alongside them — a specific subsystem, an integration, or the AI layer — to the same standards, in your repository, reviewed by your people.
What happens after launch?
Whatever you want to happen. Some clients take it in-house immediately, some keep us on for ongoing development. The handover is the same either way, because it is written for someone who isn’t us.
Next step
Have a software project in mind?
Bring the process, not a specification. The discovery call produces a scope and a fixed price, and you keep both.