Build software where no product fits, and put it into use.
For the part of your business that works differently, and for the links between systems that were never meant to meet. Small releases, real users from the first weeks, and a plan for who looks after the software when we leave.
A large company, simplified Example
Development view
Customers
- Marketing
- Sales
- ServiceBuild
- Online channelsBuild
Operations
- Planning
- Supply chain
- Fulfilment
- Procurement
Corporate
- Finance
- People
- Legal and risk
- Reporting
Foundations
- Data
- IntegrationBuild
- Infrastructure
- Security
- You get
- Working software in releases, the source code in your repository, tests, documentation and a support plan.
- Typical length
- Discovery: 2 to 4 weeks. First release: 8 to 16 weeks after discovery.
- Priced as
- Discovery: a fixed fee. Building: by release at an agreed price, or by time with a monthly cap.
When you need it
- The process is part of how we compete, and no product supports it well.
- Products cover most of the need, and the rest lives in spreadsheets.
- Our systems have to exchange data, and no connector exists.
- Customers and partners need a portal into our own systems.
- We want AI inside our own systems, and no product does what we need.
What you get
- Working software
- Released in stages, each one usable.
- Source code
- In your repository from the first day.
- Documentation and runbooks
- For the people who will run and change it.
- Automated tests and a release pipeline
- So changes can be made safely after we’ve gone.
- Security review
- A review of the code and its settings before release, for anything that touches personal data. Penetration tests need a specialist; we help you scope one.
- Support plan
- Agreed before launch: who handles what, and how quickly.
Before we build
We check the market first. If a product covers most of the need, we recommend it. Parts that can be bought usually are.
What we build
- Web applications and portals
- For customers, partners and staff, designed with the people who will use them.
- Integrations and APIs
- Between products, older systems and partners, documented and monitored.
- Workflow and automation
- Removing re-keying and the spreadsheets that hold processes together.
- Data pipelines and reporting
- The numbers the business runs on, brought into one place.
- AI features
- Document handling, search across your own information, and assistants inside your tools. Each is measured against today’s way of working, with a person checking where mistakes are expensive.
- Mobile apps
- For people who work away from a desk.
How it runs
- Discovery
2 to 4 weeks
Users, data and constraints. It ends with a tested design and an estimate for the first release.
- Decision point
First release
You approve the design and the estimate, change them, or stop.
- Build and review
Every two weeks
Working software shown, and priorities agreed with your product owner.
- Each release
Quality checks
Automated tests, code review, and a security review where personal data is involved.
- Decision point
Release
Your product owner decides whether each release goes live.
- Launch
Into use
Data migration where needed, training by role, and a rehearsed launch.
- Handover
After launch
Runbooks, documentation and training for your team or your support partner.
What you provide
- A product owner who can make decisions every week.
- Access to the people who will use the software.
- Your standards for hosting, security and code.
- A plan for ownership after launch. We help you make one.
Length and pricing
- Typical length: a discovery of 2 to 4 weeks, then 8 to 16 weeks to a first release.
- Priced as: discovery at a fixed fee; building by release at an agreed price, or by time with a monthly cap. The estimate for each release is agreed before it starts.
Questions
Who owns the code you write?
You do, and it sits in your repository from the first day. Tools we owned before the engagement, and third-party components, come with a licence to use them.
Which technologies do you use?
Mainstream, well-supported technologies that your own team or another partner can work with later. We avoid niche tools that would tie you to us.
Where does the software run?
In your environment, on your cloud or servers and under your security policies. We don’t host or operate production systems.
Can you work with our own developers?
Yes. We agree the standards, the review rules and who approves releases with your team at the start.
What happens after launch?
We stay through the first weeks of use. After that, support moves to your team or a partner, or stays with us under a separate support agreement for the software we built.
How do you decide whether to build or buy?
We check the market before anything is built. A product that covers most of the need is usually cheaper to own over five years. We build where the business really works differently, or where systems must exchange data and no connector exists.
Tell us what you’re trying to decide or fix.
A line or two is enough. We read every enquiry ourselves and reply within two working days.
What happens next
- We reply to arrange a call. If we’re not the right fit, we say so.
- A first call of 30 to 45 minutes with the person who would lead the work.
- A written proposal for the first stage: scope, deliverables, length and fee.
We can sign a non-disclosure agreement, yours or ours, before you share anything sensitive.