Build · Custom CRM
A CRM that matches how you actually sell
Most teams don't leave their CRM because it lacked features. They leave because it asked them to work somebody else's way, so nobody kept it up to date. We build CRMs around your pipeline, your language and your stages — and we start with a fixed-fee discovery, so you know what you're buying before you commit to building it.
First, an honest question
Should you even build a custom CRM?
Often the answer is no, and we'll say so. A configured off-the-shelf CRM is cheaper to start, faster to launch and somebody else maintains it. If your sales process looks like everyone else's, that's the right call and we'll happily help you set one up properly.
Custom earns its keep when the standard shape of "lead, opportunity, close" doesn't describe what your business actually does — and when the workarounds are already costing you more than the licences.
Build custom when
- Your process is the product — surveys, site visits, tenders, drawdowns, renewals or compliance steps that no CRM ships with.
- Half your team lives in spreadsheets — because the CRM can't hold the thing they actually need.
- The integrations are the point — pricing, stock, jobs or billing live elsewhere and must stay in step.
- Per-seat costs punish growth — you're paying for hundreds of seats to use a fraction of the product.
- The data is sensitive — residency, retention and access rules you need to set yourself.
How we work
Three frameworks holding the project up
One for how we engage, one for how the system is built, one for how it's delivered. They exist so a CRM project stays predictable — the part clients usually tell us went wrong last time.
Engagement
Discovery is fixed-fee and time-boxed, so the riskiest, least-understood part of the project has a known cost. Build then runs in fixed-scope phases, or capped sprints where the risk is genuinely open-ended.
- Named product owner on both sides
- Weekly status, one page
- Risk and decision log kept in the open
- Change control with an impact note before anyone commits
Architecture
API-first and modular, so the CRM can talk to accounts, marketing, support, telephony and billing without being rebuilt. Configuration where configuration will do; custom only where it earns its place.
- Core records: leads, contacts, accounts, opportunities, activities, quotes, cases, tasks, users, roles
- Security by design: roles, audit trail, encryption, SSO, UK data residency
- Reporting layer built in, not bolted on
Delivery
Deliberately hybrid: discovery and design are planned up front, because you can't sprint your way to a data model. Build, test and release then run in two-week increments you can see and use.
- Written acceptance criteria and a shared definition of done
- Sprint demo every two weeks — no big reveal at the end
- Staging environment for user testing before production
- Hypercare after go-live, then support and roadmap
The process
Seven phases, start to steady state
Durations are typical, not promises — scope, integrations and the state of your existing data move them more than anything else. Discovery gives you a version of this table with your own numbers in it.
| Phase | Focus | What you get | Typical |
|---|---|---|---|
| 1. Discovery & strategy | Stakeholder interviews, process mapping, data audit, integration inventory, success measures | Vision and requirements, process maps, prioritised backlog, roadmap, estimate | 2–4 weeks |
| 2. Solution design & UX | Data model, workflows, roles and permissions, wireframes, integrations, tech choices | Solution blueprint, data model, API contracts, clickable prototype, test strategy | 2–4 weeks |
| 3. Build & configure | Custom modules, automation, interface, reporting, notifications | Working software every two weeks, sprint notes, test cases, admin documentation | 6–16 weeks |
| 4. Integrate & migrate | Accounts, email, marketing, support, telephony; cleanse, de-duplicate, rehearse the migration | Integration map, migration scripts, validation reports, rollback plan | Overlaps 3 |
| 5. Test & UAT | Functional, security, performance and regression testing, then your people trying to break it | Test summary, defect log, UAT sign-off, go/no-go recommendation | 2–4 weeks |
| 6. Deploy & train | Cutover, go-live, training by role, written ways of working | CRM in production, training materials, runbook, admin guide | 1–2 weeks |
| 7. Hypercare & optimise | Close support, adoption tracking, backlog refinement, planning the next phase | Hypercare report, KPI dashboard, optimisation roadmap | 4–8 weeks |
Data quality is the usual surprise. If your current records are duplicated, half-filled or spread across three systems, phase 4 gets longer — and we'd rather tell you that in week two than week twenty.
What's in it
The parts every CRM needs, shaped to your business
Core records
Connected to
Security by design
Decided early, not retrofitted
- Role-based access — people see the records their job needs, and no more.
- Full audit trail — who changed what, when, and what it said before.
- Single sign-on — your existing Microsoft or Google accounts, so leavers lose access the day they leave.
- Encrypted, UK-hosted — data residency you can state plainly to your own customers.
- Retention rules — what's kept, what's deleted, and when, set by you.
Reporting
The numbers your board keeps asking for
- Pipeline — what's in play, at which stage, worth what, moving or stuck.
- Activity — what the team is actually doing, without turning it into surveillance.
- Conversion — where deals are won and, more usefully, where they're lost.
- Retention — renewals, repeat work and the accounts going quiet.
- Service levels — response and resolution against what you promised.
Handover
What you actually walk away with
A CRM project ends properly or it doesn't end at all. This is what "finished" means with us.
You receive
- The CRM live in production
- Source code and ownership of it
- Migration and validation evidence
- Integration documentation and credentials
- Admin and end-user guides
- Training sessions, recorded
- Test results and UAT sign-off
- Runbook, support model and roadmap
How it's delivered
- An open backlog — you see what's being built and why
- A demo every two weeks, using real data
- A staging site to test on before anything goes live
- A written cutover plan, including how to roll back
- Hypercare: fast support in the weeks right after launch
- Handover training, then an optional support retainer
How we measure it
- Adoption — is it genuinely being used?
- Data quality and completeness
- Sales cycle time and pipeline visibility
- Lead conversion and customer retention
- Ticket resolution against service levels
- Return against the business case we agreed at the start
Commercials
Priced so the risk sits with us
Every project is quoted individually — but the shape is always the same.
Discovery
Fixed fee, fixed length. You end it owning the requirements, the process maps and a costed roadmap — whether or not we build the thing.
Build
Fixed price per phase where the scope is clear, capped time and materials where it genuinely isn't. You approve each phase before it starts.
Support
A monthly retainer with agreed response times, covering hosting, updates, small changes and the next items on the roadmap.
Changes are normal — you'll learn things in month three you couldn't have known in month one. Each one gets a short written impact note covering cost, time and knock-on effects, and nothing starts until you approve it.
Straight answers
What clients ask before they commit
Can you extend our existing CRM instead of replacing it?
Usually, yes, and it's often the cheaper answer. If your platform has a decent API we can build the missing pieces around it — a custom quoting module, a customer portal, the integration that never existed — and leave the core where it is. Discovery tells us which way round makes more sense.
What happens to the data we already have?
It gets audited early, because it's the most common cause of delay. We cleanse, de-duplicate and map it, then rehearse the migration on a copy — more than once — so go-live day is a repeat of something we've already done, with a validation report you can check and a rollback plan if it isn't right.
How do you stop the team going back to spreadsheets?
By designing around how they already work and involving them in phase one, not phase six. The spreadsheet usually exists because the system couldn't hold something — so we find out what that something is. Adoption is a measure we report on after launch, not a hope.
How long before we see something real?
A clickable prototype in design, typically within four to eight weeks of starting, then working software every two weeks after that. You'll be clicking around your own CRM long before it's finished.
Who owns the system at the end?
You do — code, data, documentation and credentials. We'd like to keep supporting it, and most clients do, but nothing is built to make leaving difficult.
What if the project needs to pause?
Phases are designed to be sensible stopping points. Because each one ends with something working, tested and documented, pausing between phases leaves you with usable software rather than a half-built system nobody can touch.
Bring us your worst spreadsheet
The one holding your pipeline together. In a free demo we'll walk through how it would look as a proper system — and tell you honestly whether custom is the right answer for you.
Book a Free Demo