Software Development
Software built around how your business works, and owned by you.
We design, build and hand over software that fits the way a business actually operates: web applications, SaaS products, mobile apps, APIs, CRM and ERP customisation, internal tools, cloud infrastructure and the data pipelines underneath them.
What you end up with
- A written technical scope with the trade-offs and the cost of each option stated
- Working software in your own repository, running in your own cloud account
- Documentation and a handover session so your team can maintain and extend it
- A stack chosen for hireability, so you are not dependent on us to keep it running
Tools and platforms
- TypeScript
- JavaScript
- React
- Next.js
- Node.js
- Python
- PostgreSQL
- React Native
- Laravel
- .NET
- Redis
- Prisma
- Docker
- AWS
- Terraform
- GitHub Actions
Services
12 services in Software Development
Each one has its own page covering what the work involves, what you receive and the trade-offs.
Custom Software Development
Applications built around your process instead of around a template.
SaaS Product Development
Multi-tenant products built to be operated, not just launched.
MVP Development
The smallest version that answers whether anyone wants it.
Web Application Development
Browser applications for work a spreadsheet has outgrown.
Mobile App Development
One codebase for iOS and Android, native where it counts.
API Development & Integration
Interfaces other systems can depend on without breaking.
CRM & ERP Development
Customisation of the systems that run sales and operations.
Internal Tools & Dashboards
The screens your team opens every morning, built quickly and cheaply.
Cloud & AWS DevOps
Infrastructure as code, configured by hand only when it has to be.
Legacy System Modernization
Replacing a system without stopping the business that depends on it.
QA & Test Automation
Tests that catch regressions before your customers do.
Data Engineering & Pipelines
Moving data reliably from where it is created to where it is used.
How we think about it
Why software development projects fail
The technical detail that decides whether this work pays back, written for someone who has to sign off on it.
Custom software is a maintenance commitment, not a one-off purchase
The build cost is the smaller half of the bill. Software has to be deployed, monitored, patched, backed up and eventually changed, and someone has to do that work every month for as long as the business depends on it. We price the ongoing care honestly before a project starts, write the documentation as we go rather than at the end, and design so that a developer who has never met us can pick the code up without a handover call.
Buy before you build, and build only what is specific to you
Most problems already have a product that solves them, and configuring that product is cheaper and safer than writing your own. Custom code earns its place when the process is genuinely different from how everyone else works, when integrations between existing systems are the real problem, or when licence costs scale faster than the value delivered. We say which case yours is, including when the answer means less work for us.
The stack should be boring and hireable
Exotic technology is a quiet liability. It makes the software harder to staff, harder to hand over and harder to find help with when something breaks at an inconvenient hour. We default to widely used tools with large communities, TypeScript, React, PostgreSQL, Node.js, Python, and we choose something unusual only when there is a specific reason, written down, that justifies the long-term cost.
Scope first, then ship in small increments
Projects go wrong at the scoping stage far more often than at the coding stage. We spend real time on the written scope, agree what is not being built, and then deliver in small increments so there is working software early instead of a large reveal at the end. Each increment is something you can look at and change your mind about, which is the cheapest possible time to change your mind.
Questions
Before you book a call
How long does a typical project take?
It depends entirely on scope. A focused web application with authentication and one core workflow is measured in weeks. A multi-tenant product with billing, roles and an admin console is measured in months. A migration off a legacy system is measured in quarters and is deliberately staged. We give a range after scoping and we would rather give you an uncomfortable range than a comfortable number we do not believe.
Who owns the code and the infrastructure?
You do, from the first commit. Repositories live in your organisation, cloud accounts are in your name, domains and vendor accounts are yours, and there is no proprietary framework or private build step that only we can operate. That is a deliberate choice: it means leaving us is possible, which is the only basis on which staying with us means anything.
We already have an internal developer. How does that work?
Usually well. We can lead the build with your developer embedded, work alongside them on the parts they cannot get to, or take a specific module end to end. We write for the person who inherits the code, review their work if useful, and hand over knowledge rather than guarding it.
Do you work fixed price or by the hour?
Both, depending on how well defined the work is. A well-specified piece of work can be fixed price, with a written list of what counts as a change. Exploratory work is better on a time-and-materials basis with a fortnightly view of spend. Fixed price is not automatically safer for you, it just moves the cost of uncertainty into a contingency and a stricter change process.
Tell us where the manual work is
A 30-minute call. We map the process, tell you what we would automate or build first, and what it costs. No retainer before you agree the scope.
- No retainer before scope is agreed
- Written plan you can act on alone
- Worldwide delivery, on your hours