Capabilities

Strategy, design, engineering, operations.

One team that can carry a product the whole way, so nothing is lost in a hand-off between an agency, a contractor and a vendor.

01 What we do

Six disciplines, one team.

Each of these is work we do ourselves. None of it is subcontracted, which is what makes one team accountable for the result.

01

Product strategy and design

We start by writing down what the product has to prove and for whom. Research, flows, interface design and a working prototype come before a line of production code.

  • Discovery and scoping
  • Interface and interaction design
  • Prototypes people can use
02

Mobile apps

Native-quality apps for iOS and Android from one codebase. Subscriptions, sign-in, camera features, offline use and store submission are part of the build, not extras.

  • iOS and Android
  • In-app purchases and subscriptions
  • App Store and Google Play release
03

Web platforms and APIs

The services behind the screen: APIs, data models, admin tools and the cloud infrastructure they run on. Built to be observable, inexpensive to run and straightforward to hand over.

  • Cloud-native backends
  • Third-party integrations
  • Internal tools and dashboards
04

Data and applied AI

Computer vision, search and language models, used where they measurably improve the product. Every model-driven feature ships with a benchmark, a budget and a fallback.

  • Image recognition
  • Search and retrieval
  • Evaluation and cost control
05

Security and privacy engineering

Least-privilege access, encryption in transit and at rest, secrets kept out of clients, and telemetry that collects only what it names. Privacy is a design input, not a review step.

  • Threat modelling
  • Data minimization
  • Audit-ready logging
06

Operations and support

We run what we ship. Monitoring, incident response, dependency updates, store compliance changes and user support continue after launch.

  • Monitoring and on-call
  • Release management
  • User support
02 Process

From baseline to operation.

Five steps, the same on every project. The names are plain because the work should be easy to follow.

  1. Scoping

    A conversation, then a written scope: what we are building, what it does not include, what it costs and the date it lands. You approve it before anyone writes code. There is no charge for this part.

    You get A fixed scope, a price and a schedule

  2. Design

    Flows and screens, then a prototype you can tap through on your own phone. We test the riskiest assumption here, while changing it is still cheap.

    You get Screens, a clickable prototype, a decision log

  3. Build

    Two-week cycles, each ending in something you can install. You get a TestFlight and Play internal build, a short written update and a running list of what is done.

    You get Installable builds every two weeks

  4. Release

    Store listings, privacy declarations, screenshots, review responses. We have been through App Store and Play review enough times to know what gets rejected and why.

    You get A live listing on both stores

  5. Operate

    Monitoring and alerting, dependency updates, OS and store policy changes, and user support. Monthly, cancellable, with a report of what was spent and why.

    You get Uptime, updates and a monthly report

03 Working together

Three ways to engage us.

A

Fixed-scope project

A defined product taken from scope to store release for an agreed price. Best when you know what you want built and want a number you can budget against.

Typically 8–14 weeks

B

Monthly team

Our designers and engineers working as your product team, inside your tools and your release process. Best when the roadmap is still moving.

Rolling, one month's notice

C

Audit and rescue

A written assessment of a product you already have: what works, what is risky, what it would cost to fix, in priority order. Then the fixing, if you want it.

Two weeks to the report

04 Questions

The things people ask first.

How long does a first release take?
It depends on scope. A focused first version — one product, the core feature working on real data — is usually eight to fourteen weeks from kickoff to store submission. You get a schedule with dates in the written scope, before any work starts.
What does it cost?
Projects are priced either as a fixed scope or as a monthly rate for a dedicated team. We give you a number after a scoping conversation rather than before one. That conversation is free, and so is the scope we write from it.
Who owns the code?
You do, from the first commit. Where you already have a repository we work in it. Where you do not, we set one up in your name and hand over the keys.
Can you work with our existing team?
Yes. We take on a whole product, a single platform, or a piece of work alongside your engineers using your tools, your branching model and your review process.
Do you sign NDAs and healthcare agreements?
Yes. We sign mutual NDAs as a matter of course. Where a project involves protected health information, the agreements and safeguards the law requires are in place before any real data reaches us.
What do you build with?
Typed, well-supported, slightly boring tools: one codebase for iOS and Android, managed cloud services behind it, and nothing we could not still support in three years. We pick the stack to fit the product and the budget it has to run on.
What happens if we stop working together?
The software keeps running. Everything is already in your accounts, the deployment is documented, and we will brief whoever picks it up. There is no proprietary layer of ours to unpick.

Contact

Have a product in mind?

Tell us what you are building, or what is not working. We will reply with a plain answer about whether and how we can help.