Services

We build custom software to a specification you have signed.

We build web applications, internal tools, back-office systems and APIs. Each starts as a written document and ends as tested code in a repository you own.

Most projects go wrong before the code

Custom software usually fails on scope, not on code. The scope lives in meetings and memory, so the supplier builds one thing and the client expects another. The gap shows up late, as delays, extra invoices and a system staff avoid. We close it on paper first, where a change costs a conversation, not a rebuild.

The specification states what the system does, what it leaves out and the tests it must pass. It is yours, and another supplier can quote against it.

What you get

  • A signed specification

    Screens, data, roles, rules and acceptance tests in one document. It also lists what is out of scope.

  • Working releases on staging

    A new increment every 2 weeks. You check real features against the acceptance criteria as they arrive.

  • A test suite that runs itself

    Tests run on every commit. Acceptance tests run before each release, and you can read the results.

  • Deployment you can repeat

    Scripts and configuration rebuild the system from the repository. No step depends on one person's laptop or memory.

  • Documentation for the next developer

    Architecture notes, a runbook, a setup guide and a recorded walkthrough, written for a developer who has never met us.

When this service fits

Choose this service when packaged software cannot follow the way your business runs. It also fits when an existing system has become the bottleneck: slow to change, undocumented, or propped up by spreadsheets.

It is the wrong choice when an off-the-shelf product covers most of what you need. Buy the product, and use our integration service if it must exchange data with other systems. If you cannot yet describe the process, commission the discovery alone.

How the work runs

  1. Discovery and specification

    One week. We read what exists, interview the people who run the process and write the specification.

  2. Foundations first

    The first increment sets up the repository, the test pipeline and staging. It also delivers one thin feature that works from screen to database.

  3. Build in 2-week increments

    Each increment ships to staging with its tests. New ideas get a written change request that states the effect on price and timeline.

  4. Go-live and handover

    The acceptance suite runs, the rollback plan is written and you approve the release. Then we hand over documentation and credentials.

A typical engagement

Discovery
1 week, ends with a written specification
Build length
8 to 16 weeks for a first release
Progress reporting
Written note every week
Handed over
Repository, tests, deployment scripts, documentation, credentials
After go-live
30 days of defect fixes at no charge

Questions buyers ask

Can you give a fixed price before discovery?

No, because nothing is fixed yet. After the 1-week discovery we quote against the specification. If the quote does not suit you, the document is still yours.

How much of our time does the build need?

Plan for one named person who can answer questions and test each increment. That is usually a few hours a week, more during discovery and before go-live.

Can our own developers take over afterwards?

Yes, and we plan for it. Code, tests and documentation sit in your repository from day one. We choose well-documented tools so another team can maintain them.

Send a short description of the system you need and we reply within 2 working days.

Start a project