Discovery and Process Mapping
We sit with the people doing the work, document how it actually runs, including the workarounds, and identify where software helps and where a simpler change would do.
Custom Software Development
Custom Software Development for Business Workflows
We design software around processes that standard tools cannot support efficiently.
NovaCraft maps workflows, integrations, permissions and data requirements before designing, building, testing and documenting a maintainable system for your team.
- Bespoke Systems
- Integrations & Automation
- Your Code, Your Data
- Discovery and process mapping
- Systems architecture
- Bespoke application development
- API design and integration
- Process automation
- Data migration
- Legacy modernisation
- Reporting and analytics
- Documentation and handover
- Long-term maintenance
Build, buy, or leave alone
Decide When Custom Software Is Justified
Before recommending a build, we test the idea against four questions:
Does an existing product already do this acceptably well?
Is the process actually stable, or still changing every month?
What does the manual version cost you per week, in hours and errors?
Who maintains this in three years, and can they?
If a product off the shelf gets you eighty per cent of the way for a fraction of the cost, that is usually the better decision, and we will say so. Custom software earns its place where the process is genuinely yours, the volume is real, and the alternative is a permanent manual tax.
When it is the right call, the goal is a system your team owns and can hand to someone else. Software that only its original authors can maintain is a liability with a nice interface.
What we can build
Custom Software Development Scope
These projects begin with discovery rather than a quote. Until the process is mapped, any number would be invented.
Bespoke Business Systems
Applications built around your own operations: quoting, scheduling, inventory, case management, approvals, whatever shape your process genuinely takes.
Systems Integration
Connecting tools that do not talk to each other, so data moves once and automatically instead of being exported, reformatted and re-entered.
API Design and Development
Documented, versioned interfaces for your own products or partners, with authentication, rate limiting and predictable errors.
Process Automation
Removing repeated manual steps, generating documents, reconciling records, chasing approvals, moving files, where the return is measured in hours per week.
Data Migration
Moving records out of spreadsheets or an old system, cleaning them, mapping them and verifying the result before anything is switched off.
Legacy Modernisation
Working with systems that still do the job but are risky to change, replacing them in stages rather than betting the business on one cutover.
Reporting and Analytics
Pulling numbers from several systems into one place, so the monthly report stops being a day of copy and paste.
Our toolkit
Technology for Maintainable Custom Systems
For software you intend to keep, the most valuable property of a technology is how easily you can hire someone who knows it. We choose accordingly.
Application
- TypeScript
- Node.js
- React
- Next.js
Used for application logic and interfaces. One language across front and back end keeps a small team effective on both.
Data
- PostgreSQL
- Prisma
- Redis
Used for schema design, migrations, queries and caching. Relational by default, because most business data genuinely is.
Integration
- REST
- GraphQL
- Webhooks
- Message queues
Used to connect systems reliably, including retries, idempotency and handling the case where the other service is simply down.
Infrastructure
- Docker
- AWS
- Vercel
- GitHub Actions
Used for reproducible environments, deployment pipelines and rollbacks that do not depend on one person’s laptop.
Quality and Operations
- Vitest
- Playwright
- Sentry
- Structured logging
Used for tests on business-critical logic, plus the monitoring needed to find out what happened when something goes wrong at 2am.
Built to outlast us
Build for Long-Term Maintainability
The real risk in a bespoke build is not that it fails to work. It is that in two years it works, nobody understands it, and the only people who did have moved on.
We treat that as a design constraint. Mainstream tools, conventional structure, written decisions and infrastructure you control, so that continuing without us is a choice rather than a crisis.
Every project we hand over includes:
- Source code in a repository you own
- Infrastructure and hosting in your own accounts
- Environment configuration documented, secrets never in code
- Database migrations that can be run and reversed
- A README that gets a new developer running locally
- Architecture notes explaining why, not just what
- Decision records for choices that will look odd later
- Automated tests on business-critical logic
- Error monitoring and structured logs
- Backup and restore procedures that have been tested
- A handover session with your team or your next supplier
- No proprietary framework that only we can work in
We would rather be kept because the work is good than because leaving is difficult.
Who this suits
Need Software Built Around Your Workflow?
Process-Heavy Operations
Businesses whose competitive advantage is a way of working that no standard product models properly.
Multi-System Businesses
Where four tools each hold part of the truth and someone reconciles them by hand every week.
Spreadsheet-Run Companies
Where a workbook has become critical infrastructure, with all the version and access problems that brings.
Scaling Service Businesses
Teams where growth is limited by admin overhead rather than by demand.
Legacy System Owners
Businesses on software that still works but is unsupported, undocumented or expensive to change.
Product Companies
Firms needing an API, a partner integration or an internal platform alongside their main product.
What you receive
What the Software Project Delivers
Scope varies widely. A typical engagement may include:
- Process map of the current workflow
- Requirements and scope document
- Systems architecture and data model
- Integration plan for existing tools
- Interface designs for the screens people use
- Application build, front and back end
- API development and documentation
- Data migration with verification
- Automated tests on critical logic
- Staging environment for sign-off
- Deployment pipeline and environment setup
- Monitoring, logging and alerting
- Technical and administrative documentation
- Training for the people who will use it
- Handover session and source code transfer
- Optional maintenance and support agreement
Client project management
How we manage custom software projects
The delivery method stays visible to both teams. Scope, responsibilities, feedback, approvals and handover are documented from the start.
Written scope and responsibilities
We document deliverables, responsibilities, dependencies, review points and exclusions before production begins, so every participant works from the same agreed scope.
One shared project workspace
Files, notes, decisions, links and current priorities stay in one shared workspace, giving both teams a consistent source of project information.
Weekly status and next actions
Each week we record completed work, current tasks, blockers, decisions required and the next review point, keeping progress visible without constant meetings.
Structured feedback and approvals
Feedback is consolidated by the client decision owner, reviewed against the agreed objective, then recorded before the next production stage begins.
Documented scope changes
Requests outside the approved scope are documented with their impact on timing, effort and dependencies before either team commits to the change.
QA, handover and next steps
Before handover, we review agreed acceptance criteria, test required journeys, document remaining actions and confirm ownership for launch or ongoing support.
Working instructions
What we agree with the client at kickoff
- Nominate one client decision owner for consolidated approvals.
- Share required access, brand assets and source material before the relevant stage begins.
- Return consolidated feedback against the agreed review date whenever possible.
- Use the shared workspace for decisions so important context is not split across channels.
- Raise blockers and changing priorities early so timeline or scope impact can be reviewed before work continues.
Frequently asked questions
Custom Software questions we are asked most
Start with what exists. If a standard product covers most of your process at a fraction of the cost, buying is usually right even with some compromise. Custom software makes sense when the process is genuinely specific to you, the volume justifies it, and the manual alternative has a real weekly cost. We give you that assessment during discovery, including when the answer is "buy".
It depends entirely on scope, and we will not give a figure before understanding the process. What we can do is a short paid or unpaid discovery stage that produces a scope, an architecture and a realistic estimate, after which you are free to take it elsewhere.
A focused tool automating one process might take four to eight weeks. A system replacing several tools and holding critical data usually runs three to six months, delivered in stages so you get working software early rather than everything at the end.
You do, both. Code goes in your repository, infrastructure sits in your accounts, and your data is yours throughout. There is no proprietary layer that has to be licensed from us.
Usually. Most modern tools offer an API or webhooks, and we can work with files or scheduled exports where they do not. During discovery we check what each system actually allows, because published integration capability and real integration capability sometimes differ.
It gets migrated, and that is a project in itself. We map fields, clean what needs cleaning, migrate into a staging environment first, and verify record counts and samples with you before anything goes live. Nothing is switched off until the new system is proven.
They usually do. We work in stages with regular working builds, so changes are discussed against something real. Significant changes to scope are re-estimated openly rather than absorbed quietly and recovered elsewhere.
That is what we build for. Conventional technology, documented architecture, tests on critical logic and a handover session. If you would rather we maintained it, that is available as a separate agreement, not as a necessity.
Often the sensible approach is to leave it running and build around it, replacing capability in stages. A single cutover on a system the business depends on is rarely worth the risk when a phased path exists.
Other services
What else we can help with
Start with the process
Show us the part of the business that runs on workarounds
Every business has one: the process held together by a spreadsheet, a shared inbox and somebody remembering. That is usually where custom software pays for itself.
Tell us how it works now, who it involves and what it costs you when it goes wrong.
Discovery before estimates. An honest build-or-buy recommendation. No lock-in.