Skip to content
1961 Digital TransformX

Service

Most custom software should never have been written.

Building software is the most expensive way to solve a problem nobody has defined yet. We check first whether a configured product already does it. Where nothing fits, we build, document and hand over — source included.

You will recognise this

  • A developer built your system, left the company, and nobody now knows how the pricing rules work.

  • Two systems hold the same customer, and a person retypes each order from one into the other.

  • Your field crews photograph paperwork and send it on WhatsApp because there is no app for them.

  • A quotation takes three days because the engineer rebuilds every one from a fresh blank spreadsheet.

  • Suppliers telephone to ask about payment because they have no way of seeing the status themselves.

How the work runs

  1. Prove it cannot be bought

    We take your process to the products already on the market and try to configure it. Most requests end here, and we say so in writing. A configured product is cheaper to run and cheaper to leave. Only what survives that test reaches the build list.

  2. Write the process down

    We sit with the people who do the work and record what actually happens, including the steps nobody documented. The exceptions matter more than the ordinary path: the rush order, the partial delivery, the customer who always pays late, the job that gets re-costed twice.

  3. Build the thin slice first

    We build the smallest version a real user can run on real data, and put it in front of them within weeks. Every later decision is argued against something working rather than against a document. Scope disputes end quickly when there is a screen to point at.

  4. Integrate and reconcile

    Where the build talks to your ERP, your accounting or a supplier system, we agree which side owns each field before any code is written, then move data one direction only. Both sides are reconciled for a full period before anyone stops entering it by hand.

  5. Hand over the keys

    You receive the source, the repository, the deployment steps and the tests, plus a working session with your own developers or the ones you hire next. We stay on support because you chose to keep us, not because leaving is impossible.

What you are handed

  • Source code in a repository you own outright
  • Written specification of every process the build covers
  • Automated tests that run before each release
  • Deployment, backup and rollback runbook
  • Integration map naming the record of truth per field
  • Recorded training for users and for your developers

The build we talk you out of

Most requests for custom software describe a process a standard product already handles under a different name. What makes it look unique is usually history: somebody configured the old system badly, the workaround became the procedure, and ten years later the workaround is being quoted as a requirement. We test that before we price anything. We take your steps to the products on the market and try to configure them, and when one fits we say so, even though it is the smaller invoice. Custom code is a liability you carry every year afterwards. Configuration is a cost the vendor mostly carries for you.

Integrations are where the money leaks

The most useful build is often not an application at all. It is the piece between two systems that will not talk: the ERP and the machine on the shop floor, the accounting ledger and the bank file, the CRM and the portal your customers log into. That gap is currently staffed by a person with two windows open, retyping a hundred records a day at roughly the accuracy you would expect. Before we write anything we agree which system owns each field, so the flow has one direction and one answer. Two-way sync with no named owner produces a disagreement neither side can win.

Handover is a deliverable, not a favour

A custom build is only worth having if you can leave the firm that wrote it. So the source sits in a repository under your account from the first commit, not ours. The specification is written in the language your staff use, not buried in a ticket queue. The tests stay readable, because they are the only honest record of what was decided the software must do. Deployment is a documented sequence a competent engineer can follow without telephoning us. We would rather keep your support work by being good at it. A client who cannot leave stops telling us the truth.

Questions we get asked

How do I know you are not just selling development hours?
Because the first stage is an attempt to talk ourselves out of the work. We try to configure your process in a product you can buy, and the stage ends in a written recommendation either way. We earn no licence commission on whatever we point you towards, so nothing tilts the answer. When a build genuinely is needed, the document says which part and why.
What does a custom build cost to keep running?
Plan for a share of the build cost every year, permanently. Servers, security patches, keeping pace with whatever it connects to, and changes when the business changes. That figure belongs in the decision at the start rather than surfacing in year two. It is the main reason we push configured products first: the vendor carries most of that burden instead of you.
Who owns the code if we stop working with you?
You do, from the first commit. The repository sits under your account, the licence is yours outright, and we hold no key that switches anything off. If you move to another firm we hand over the same package we would give a new engineer of ours: source, tests, runbook and a walkthrough call. There is no exit fee and no credential we keep back.
Our last custom project was abandoned halfway. Why is this different?
Usually the first working version was scheduled for month nine, so nobody saw anything until most of the budget had gone. We put a running slice on real data early and argue every later decision against a screen. If the idea is wrong, it fails in week six, when stopping costs almost nothing and the lesson is still affordable.
Can you build a mobile app for our site teams?
Yes, and the first question is whether the crew has signal and clean hands. Field apps fail on practical detail: a form of thirty fields nobody finishes, a photo upload that dies on a weak connection, a login that expires in a basement. We design short forms that capture offline and sync when the phone finds a network again.

Tell us what is not working

Send one line about what is going wrong. On the first call we will tell you whether it is a system problem, a process problem or a governance problem — and which one to fix first. That call is free and it is not a sales meeting.

Book a consultation