Skip to content

Research and software development

Find out what your software costs before you commit to building it

Most quotes are a guess dressed up as a number. We start with a short piece of paid work, and you get back a written plan covering scope, sequence and cost.

Book a discovery call How the work runs
  • Written plans
  • Named teams
  • Costed changes
  • You own everything
  • Bad news early

Services

Six disciplines, one way of working

Different problems, same starting point. We learn enough about yours to price it in writing before anyone builds anything.

01

Product

Web and Mobile App Development

Products people sign into and use. iOS, Android, and the browser.
02

Existing systems

Software Development and Maintenance

New features on an existing product, and keeping a running system healthy. Often the work nobody wants to quote for.
03

Models

AI and Machine Learning

Models put into production and kept working there, which is a different job from getting one working once in a notebook.
04

Ledgers

Blockchain and Distributed Systems

Contracts, wallets and the infrastructure around them, where a ledger genuinely solves the problem you have.
05

Screens

Product and Interface Design

Research, flows and screens, either ahead of a build or as its own piece of work.
06

Releases

Testing and Quality

Finding what breaks before your users do.
07

Project Management and Delivery

For teams that have engineers but nobody running the work.

How the work runs

Three steps. The first one is the product.

Everything else on this site follows from these three steps.

  1. 01

    Discovery that ends in a written plan

    A short piece of paid work. We sit with the problem and you get back a document that says what is being made, how it fits together, what order it gets built in, and what it costs. The plan is yours unconditionally. Take it to us, take it to another firm, or decide not to build at all.

  2. 02

    A named team, and one person you can reach

    The people who understood the problem build the thing. You get names rather than a rotating cast, and one lead who answers to you directly. If someone is not working out, we raise it first and manage the replacement ourselves.

  3. 03

    Progress you can check, changes you can price

    Work arrives in increments you can see and use, not in a reveal at the end. When scope moves, and it will, the change is costed in writing before anybody starts it.

Stack

We work in your stack

You chose your stack for reasons, and our engineers join what you already run rather than asking you to move to ours. Where we have opinions, they are about review discipline, deployment and operations, not about which framework wins.

  • Product and interfaces
    • TypeScript
    • React
    • Swift
    • Kotlin
  • Services and data
    • Node.js
    • Python
    • Go
    • PostgreSQL
  • Chain and operations
    • Solidity
    • Terraform
  • Testing and delivery
    • GitHub Actions
    • Playwright

A short, true list. Listing a technology we cannot staff loses a client in week three.

Ownership

What you own

From the first commit, everything belongs to you. Not at handover. From the beginning.

  • Code and repositories

    All of it, in accounts you control. There is no private framework underneath and no dependency on continued payment to keep the thing running.

  • Infrastructure and keys

    Cloud accounts, domains, credentials and certificates are created in your name. We hold nothing that you cannot revoke yourself.

  • Documentation

    Decisions, diagrams and runbooks are written while the work happens, so the knowledge leaves with the documents rather than with the people.

  • The freedom to leave

    If you stopped paying us tomorrow, the product would keep running without us. That is the test we design against.

Limits

When not to hire us

Four situations where we are a poor fit. Saying so costs enquiries on purpose.

Questions

Asked before deciding

Is offshore development actually cheaper?

Not automatically. The rates are lower and the coordination costs are real. It comes out cheaper when the work is well specified and the team's working hours overlap yours, which is exactly how our engagements are set up. On the call, if we think it would not come out cheaper for your situation, we will say so.

Who owns the code?

You do, from the first commit. Repositories sit in your accounts, infrastructure is provisioned under your name, and there is no private framework underneath anything we build. If the relationship ended tomorrow, everything keeps running without us.

How much does a project cost?

Anyone who answers precisely before reading the problem is guessing. The discovery engagement exists to produce a real number, and it is bounded: a fixed fee, a fixed duration, and a written plan with the cost in it. You can take that plan anywhere, including nowhere.

We already employ engineers. Is this relevant?

It can be. Two arrangements exist for exactly that case: our engineers embed in your team and work your backlog under your direction, or we take a defined area of the product and run it as a separate workstream that reports to you. Both are described on the adding engineers page.

What happens after launch?

Whatever you choose. Some clients keep us on for maintenance with a named engineer and a response agreement. Others take the documentation and run it themselves, which the way we work is designed to allow. We will tell you honestly which one suits the size of the system.

Why would we hire a firm we have never heard of?

You should not, on the strength of a website. We are early in our own life and we do not pretend otherwise, which is why the first step is small, paid, bounded, and useful even if you never speak to us again. Judge the plan, then decide about the rest.

Next step

Start with a conversation, not a contract

Tell us what you are trying to build. If we are the wrong people for it, we will say so on the call and point you at someone better suited.

Book a discovery call See how the work runs