ContactBook a call

Industries/ Startups

Build the version that tells you the truth before the runway runs out.

We work with founders building a first product, funded teams whose build has stalled, and early SaaS companies finding their feet. You get a narrow first release, code you own from the first commit, and a studio that will tell you plainly what not to build yet.

Four people laughing around a long table covered in printed app screens and sticky notes, in a brick-walled loft with wireframes sketched on a whiteboard.

Overview

Startups, today

Starting a software company is cheaper on paper than it used to be and no easier in practice. Tools that once took a team many months now come off the shelf, yet founders still run out of money building things nobody asked for. Investors want evidence earlier, customers expect polish from the first login, and plenty of first builds stall somewhere between a freelancer, an agency and a co-founder who meant to learn to code. Most founders who talk to us are not short of ideas. They are short of a clear, honest route from the idea to something customers will pay for.

In a startup the software is the product, so it sits right at the centre of the risk. The job early on is not to build everything on the roadmap. It is to build the narrowest version a real customer could use and be charged for, learn from what they actually do, and change course cheaply when the evidence says so. That means a clickable prototype before code when the idea is untested, a conventional, well-documented stack rather than something clever, and the dull foundations (accounts, billing, permissions) done properly from the start, because retrofitting them later is painful.

Good looks like a founder who can explain the product, the architecture and the monthly bill to an investor without phoning anyone. The code lives in your repository, the cloud accounts are in your company's name, and another team could pick it up next year without a rewrite. Releases go out often and safely, errors reach a person before a customer emails about them, and the backlog is ordered by what customers do rather than by who argued loudest. And when an off-the-shelf tool or a no-code build is the better answer for now, someone tells you so.

The pressures

What you are up against

What founders tell us on the first call, often before we have asked a single question.

  1. 01

    Runway shorter than the roadmap

    The quote to build everything on our roadmap would use most of the money we raised. Every month spent building before anybody pays is a month in which we learn nothing. We need someone to tell us which half of the feature list can wait, and to mean it.

  2. 02

    Our developer stopped replying

    The first version was half built by a freelancer who has since gone quiet. We have a login screen, a database nobody can explain and no documentation. We cannot tell whether to finish it or start again, and investors keep asking when customers will be able to use it.

  3. 03

    Investors will look under the bonnet

    Our next round will come with technical due diligence. Someone will ask who owns the code, how customer data is protected, what happens if our only engineer leaves and why the cloud bill grows faster than revenue. Right now we would struggle to answer any of that with confidence.

  4. 04

    Every release feels like a gamble

    Early customers each want something different, the co-founders disagree on what comes next and the backlog has turned into a wish list. Releases are rare because each one might break sign-up or billing. We need fewer, better decisions and a way to ship small changes without holding our breath.

What we build

Software for startups

The things startups most often ask us for, from the first impression on investors to the plumbing a growing product needs.

Pitch-ready brand identity

A mark, colours, type and a pitch-deck template sized for where you are now, with room to extend later. Investors, first hires and early customers judge credibility on thin evidence, so give them a company that looks as considered as the product.

Read more

A narrow first release

One workflow, real accounts and real billing, built on foundations that will not need replacing. Small enough to ship early and put in front of paying customers, so what you build next is decided by what they actually do.

Read more

Finishing a stalled build

An honest assessment of the half-finished product you were left with, then the parts that matter stabilised, tested and completed. Rebuilding by reflex is expensive, and often the existing code needs finishing rather than replacing. We will tell you which.

Read more

AI inside your product

Smart search, recommendations, summaries or document reading built into your own product, each scoped to do one job well, with the cost per customer measured before the feature goes anywhere near your pricing page.

Read more

Metrics your board trusts

Signups, activation, retention, revenue and churn pulled straight from your product and billing system into one live view, so investor updates and board packs stop costing a founder a weekend of spreadsheet work.

Read more

Phone apps and store launch

When your product needs an app, we build for iPhone and Android together and handle the store side in parallel: developer accounts, testing tracks, privacy declarations and reviewer notes, so submission never holds up a launch date you have announced.

Read more

What changes

From how it runs now to how it could

How a few everyday parts of running an early product change once the software is built properly.

TodayWith the right software
The whole roadmap is quoted and built before a single customer has used anything.A narrow first release reaches real users early, and their behaviour decides what gets built next.
The code sits on a freelancer's laptop or in an account in someone else's name.Code, cloud accounts and domain belong to your company from the very first commit.
Releases happen rarely, by hand and late at night, with everyone hoping nothing breaks.Small changes ship often through an automated pipeline, with tests guarding sign-up, billing and payments.
Investor updates mean a weekend exporting spreadsheets from billing, analytics and the product database.Signups, activation, retention and revenue sit on one live dashboard that everyone reads the same way.
The cloud bill arrives as one climbing number that nobody on the team can explain.Running costs are tracked per customer and per feature, so pricing decisions rest on real margins.

In practice

What it looks like on the ground

Three common starting points: a first product, a build that has stalled, and an early SaaS bill nobody can explain.

Founders & early-stage products

01 · Founders & early-stage products

The version that finds out whether anyone wants it

The problem
A clear idea, a limited budget, and a powerful temptation to build the full imagined product. Every month spent building before anybody pays is a month in which nothing is learned and the runway gets shorter.
What we build
A deliberately narrow first release (one workflow, real accounts, real billing), built on foundations that will not need replacing, and shipped to real users in weeks rather than quarters.
What changes
Evidence instead of opinion. What gets built next is decided by what customers actually do, and the budget that would have gone into guessing goes into the parts that worked.
More on web apps & saas

02 · Funded startups & stalled builds

The developer stopped replying

The problem
A half-finished platform, no documentation, no handover, and no certainty about what works. The instinct is to start again; the budget rarely allows it and the deadline never does.
What we build
A paid technical review producing a written assessment (what exists, what is safe, what must be replaced and what merely needs finishing), followed by stabilisation, tests around the critical paths, and completion of the remaining work.
What changes
A clear-eyed picture within a fortnight instead of a rewrite by reflex, and in most cases a working product finished for a fraction of the cost of starting over.
More on redesigns & rescues
Subscription software (SaaS)

03 · Subscription software (SaaS)

Nobody knows what a customer costs to serve

The problem
Infrastructure arrives as one undifferentiated bill. The team cannot say what the largest account costs to run, whether the free tier is affordable, or which feature is quietly eating the margin, so pricing decisions get made on instinct and the board asks questions nobody can answer.
What we build
Resources are tagged and shared costs allocated by a method the finance team can defend, producing cost per customer, per tier and per feature. Idle and oversized components go first, then the steady baseline is bought on commitment while burst capacity stays flexible.
What changes
A gross margin figure finance trusts, a clear view of which accounts are unprofitable at their current price, and a bill that stops growing faster than revenue.
More on cost optimisation

Handled with care

The details that matter here

Early decisions are cheap to make and expensive to undo. These are the ones we handle with particular care.

  • You own everything from day one

    The repository, cloud accounts, domain, app store listings and third-party services are set up in your company's name, not ours. We work inside your accounts, document as we go and use a conventional stack, so another team or your first in-house engineer could take over without starting again.

  • Ready for technical due diligence

    Investors often ask technical questions before they commit. We keep the answers easy to find: a written architecture overview, a list of dependencies and their licences, how customer data is stored and who can reach it, and how a release gets made. We build with GDPR and your customers' security questionnaires in mind.

  • Not building ahead of the evidence

    Over-building the first version is one of the most common ways a startup runs out of runway. We push back on features nobody has asked for, keep one well-organised system until growth genuinely demands more, and write down what we chose not to build and why, so it is a decision rather than an omission.

  • Running costs you can explain

    A product that is cheap to build can still be expensive to run, especially once AI features are charged per request. We estimate running costs before building, track them per customer once you have some, and choose services whose bills grow with your revenue rather than ahead of it.

Good first projects

Where to start

Small, contained projects that are useful on their own, and a low-risk way to find out whether we work well together.

Guides

Worth reading first

Questions

What startups teams ask us

Should we build our first version with no-code tools instead?

Sometimes, and we will tell you when. If the riskiest question is whether anyone wants the product at all, a no-code build, a landing page with a waiting list or a service you deliver by hand can answer it faster and for far less than custom software. Custom code earns its place when the product itself is the advantage, when you need proper accounts, billing and permissions, or when a tool's limits are already shaping what you can offer. We are glad to help you decide, even when the honest answer is that you do not need us yet.

Who owns the code, the accounts and the data?

You do, from the first commit. The repository, cloud accounts, domain, app store listings, payment provider and every third-party service are set up in your company's name, and we work inside them as invited collaborators. We choose a conventional, well-documented stack on purpose, so your first in-house engineer, or another studio, could take over without a rewrite. We would rather earn the next phase of work than rely on you being stuck with us.

Our last developer disappeared halfway through. Can you finish the build?

Usually, but not before we know what is there. We start with a paid technical review and write down what exists, what works, what is unsafe, what must be replaced and what only needs finishing. Sometimes the code is better than everyone feared and needs completing, not replacing. Sometimes a part has to go. Either way you decide with the facts in front of you, and then we stabilise the critical paths, put tests around them and finish the remaining work.

Will the product stand up to investor due diligence?

We build so that the usual questions have clear, written answers: who owns the code and accounts, how customer data is stored and protected, which open-source licences are in use, how releases are made and what happens if a key person leaves. We keep an architecture overview and a dependency list current as we go. We cannot promise how any investor will judge your product, and we do not certify anything, but we can make sure nothing in the review comes as a surprise to you.

What happens after launch?

The period straight after launch is when you learn the most, so it usually makes sense to keep some support in place. That might be a monthly allowance of improvements driven by what customers do, monitoring that alerts us when something breaks, and security updates applied before they become urgent. If you are hiring your own engineers, we help onboard them and hand over cleanly. If you would rather run it yourselves from the start, the documentation is there for that too.

Got an idea, or a build that has stalled?

Book a free first call and tell us where things stand. We will be straight about what to build first, what can wait, and whether you need us at all yet.