Custom Software & App Development
Custom development makes sense when the process you need to run does not match the software you can buy, and the workarounds have started costing more than the licence. It rarely makes sense for something an off the shelf product already does well. We will tell you which situation you are in before we quote.
1
Discover
Map the process, agree scope
2
Design
Data model and prototype
3
Build
Two week increments
4
Test
Automated and acceptance
5
Deploy
Release, handover, training
How We Work
01
Discovery and Process Mapping
We sit with the people who do the work and map what actually happens, including the steps that exist only because a system once required them. The output is a written process map, an agreed list of what the software must produce, and the controls it has to enforce.
- Stakeholder interviews and process walkthroughs
- Current state process map
- Functional and control requirements
- Prioritised scope, including what is explicitly out
02
Solution Design
We design the data model, the screens and the integrations before any production code is written. You see clickable designs at this stage, which is the cheapest possible point at which to change your mind.
- Data model and entity design
- Clickable interface prototype
- Integration and interface specification
- Security and access model
03
Build in Increments
Development runs in two week increments. At the end of each one there is working software in a test environment for you to use, rather than a status report describing progress.
- Two week development increments
- Working software in a test environment each cycle
- Fortnightly demonstration and feedback
- Change requests priced before they are accepted
04
Testing and Acceptance
We test as we build and you test before you accept. Acceptance criteria are written during discovery, so sign off becomes a checklist rather than an argument.
- Automated and manual test coverage
- User acceptance testing with your team
- Performance and load verification
- Security review before release
05
Deployment and Handover
Release into production with a rollback plan, followed by the documentation and training your team needs to run it. Source code and the deployment pipeline are handed over to you.
- Staged release with a rollback plan
- Source code and repository handover
- Administrator and user documentation
- Training sessions and a warranty period
What You Receive
- A working application running in production
- Source code in a repository you own
- Deployment pipeline and environment configuration
- Data model and integration documentation
- Administrator and user guides
- Training sessions and a warranty period
Indicative Timeline
Most engagements run between eight and sixteen weeks from discovery to a first production release. The range depends on how many systems have to be integrated and how quickly decisions can be made on your side. Discovery is quoted separately and fixed, so you can stop after it if the business case does not hold.
- Discovery: two to three weeks, quoted fixed
- Design: approximately two weeks
- Build and test: six to twelve weeks in increments
- Deployment and handover: one to two weeks
Tools and Stack
The stack we build on. Where a client already runs something different, we work in that rather than insisting on ours.
React
Component based interfaces for applications that need to respond instantly rather than reload on every action.
Next.js
Server rendering and routing for React, which keeps pages fast and properly indexable by search engines.
Tailwind CSS
Utility based styling that keeps the interface consistent and prevents stylesheet drift as an application grows.
Laravel
PHP application framework for the server side: business logic, authentication, queues and scheduled jobs.
AWS
Hosting, storage, databases and backups, with development, testing and production kept properly separated.
GitHub
Source control, code review, and the pipelines that build, test and deploy every change.
Frequently Asked Questions
How much does a custom application cost?
It depends on scope, which is why discovery is quoted separately and fixed. You get a costed proposal before committing to a build. Most of the variation comes from how many existing systems have to be integrated rather than from the number of screens.
Do we own the code?
Yes. Source code is delivered into a repository you own, together with the deployment pipeline and environment configuration. You are not locked into us for future changes.
What happens if requirements change mid project?
Change requests are priced and agreed before they enter the build. Working in two week increments makes changing direction normal rather than disruptive, provided the impact is agreed rather than absorbed quietly.
Can you work with our existing systems?
Usually. Integration depends on whether the other system exposes an API or a database we can reach. We establish that during discovery rather than assuming it and finding out later.
Who maintains it after launch?
You can maintain it in house using the documentation and training we hand over, or we can support it under an ongoing arrangement. Both are quoted separately from the build.
How is this different from buying off the shelf software?
Off the shelf is cheaper and faster when it fits, and we will say so if it does. Custom development earns its cost when the process is a genuine differentiator, or when the workarounds around a package have started costing more than the package saves.
Related Services
This sits inside our Systems Development practice. Related work: AI Services for models and automated decisions, and Managed ICT Services if you want the environment run for you after launch.
