All products
SaaS

SaaS product development

We build multi-tenant SaaS products from the first release to real scale — including the billing, permissions, admin and telemetry that quietly decide whether a product survives its first hundred customers.

  • Multi-tenancy
  • Subscriptions and billing
  • Auth and permissions
  • Admin and onboarding
  • Analytics and telemetry
  • Scaling

You are building a multi-tenant product — a platform many customers will sign in to, pay for and trust with their data. Maybe you are a founder starting from zero, or a company turning an internal tool that already works into something you can sell. Either way the hard part is rarely the feature you are excited about. It is the machinery around it.

Most SaaS products do not fail because the main feature was weak. They fail because tenant isolation was bolted on late, billing could not express the plan a sales call just promised, or the database and the team buckled at the moment growth finally arrived. We build the whole product — the visible feature and the invisible machinery — so that none of those becomes the thing that stops you.

How we build your SaaS

Shape the product

Before any code, we find the one assumption your product actually rests on — the thing that, if it is wrong, makes everything else irrelevant — and we design the smallest release that proves it. A real MVP is not a thin slice of every feature you have imagined; it is the smallest product that can go live, be paid for, and show whether people value what you are offering.

We map the tenants, the roles, the data and the flow of money, and we name the risks early rather than discovering them in month four. This is a short, fixed-fee engagement that ends in a written, costed plan you own whether or not you continue with us.

OutputA written, costed plan and a scoped MVP

Architecture and multi-tenancy

Multi-tenancy is a decision in the data layer, and it has to be made on day one. Who can see whose data, how a tenant is isolated, how you will ever migrate or export one customer without touching the rest — these are cheap to design in and brutally expensive to retrofit. Retrofitting isolation into a product that already has customers is one of the most common ways a SaaS quietly dies.

We document the target architecture up front: the isolation model, the tenancy boundaries, how billing and permissions attach to them, and the trade-offs behind each choice. You get decision records, not just diagrams, so the reasoning survives after the whiteboard is wiped.

OutputArchitecture and tenancy decision records

Build the MVP

We build in two-week iterations, each ending in working software you and real users can try — not a status report. The MVP is the product that proves value and can actually go live, so we keep it honest: we ship the core workflow end to end before we widen it, and we resist the pull to add one more feature before the first one has earned its place.

The same senior people who scoped the work write the code. There is no hand-off down a chain, so the person answering your question in week six is the person who made the decision in week two.

OutputA working MVP, shipped in fortnightly releases

Billing, auth and admin

Subscriptions and billing are a product surface, not a checkout button bolted on at the end. Plans, proration when someone upgrades mid-month, trials, dunning when a card fails, tax and VAT across borders — each of these is a place customers leave or stay, and we build them as deliberately as any feature they can see. Getting billing wrong is how a product loses revenue it has already earned.

Around it we build the rest of the machinery every serious SaaS needs: authentication, roles and permissions that map to how your customers are actually organised, an admin surface your own team can run the product from, onboarding that gets a new tenant to value quickly, and telemetry so you can see what people do instead of guessing.

OutputBilling, auth, roles, admin, onboarding and telemetry

Launch and scale

Before go-live we harden what we built: load testing against realistic traffic, a security pass, and failure drills so you know how the product behaves when something breaks rather than finding out from a customer. Then we launch the MVP and scale deliberately, because the part that breaks first under growth is almost never raw compute — it is the database, and the organisation around it.

Scaling is sequenced, not panicked: we watch where the real load lands, fix the actual bottleneck, and keep the product running throughout. You get a readiness report before launch and a clear picture of what to reinforce next as you grow.

OutputA hardened launch and a deliberate scaling plan

Operate, evolve and co-own

As the product grows, reliability, security and compliance stop being optional. We build GDPR handling, data residency and sensible operational practice in as the product matures, rather than scrambling when a large customer's procurement team asks. The goal is a product that can pass that review, not one that hopes to avoid it.

Throughout, you own the product and the roadmap — the code and the know-how stay with you, and we document and train so your team can run and extend it. We can keep building alongside you for as long as that is useful, as a co-owner of the work rather than a gatekeeper you depend on.

OutputOperations, compliance, documentation and full ownership

What you get

  • A scoped MVP and a written, costed plan
  • Multi-tenant architecture with isolation designed into the data layer
  • Subscriptions and billing: plans, proration, trials, dunning, tax and VAT
  • Authentication, roles, permissions and an admin surface
  • Tenant onboarding and product telemetry and analytics
  • A readiness report, plus GDPR and data-residency handling
  • Full documentation, training and ownership of the code

How we think about SaaS

We treat the unglamorous parts as the product. The demo everyone remembers is the main feature; the reason a customer renews is that billing was correct, permissions did what they expected, and the admin tools let someone fix a problem without a developer. We spend our attention where it decides whether you keep the revenue, not only where it is fun to build.

We also build so that next year is cheaper than this one. Tenancy, billing and auth are the three things that calcify fastest in a SaaS, so we get their shape right before we move quickly on everything above them. Working in slices with a demo every two weeks keeps you steering the product, not receiving it — you see where it is going while there is still time to change direction.

And we build to hand over. A product you cannot run without the people who wrote it is a liability, however good it is, so documentation and training are part of the work, not a closing task.

Common questions

Can you productise our internal tool instead of starting from scratch?

Often, yes, and it can be a strong starting point — a tool people already rely on has proven its value in a way a blank page has not. The work is usually less about new features and more about the things single-tenant internal software never needed: separating one customer's data from another, adding billing and sign-up, and hardening security for people outside your company. We start with a short assessment of what carries over and what has to be rebuilt, so you decide with real numbers.

What counts as a real MVP?

The smallest version of the product that can go live, be paid for, and prove whether customers value it. It is not a cut-down version of every feature on your list — that is just a slow way to build everything. A real MVP does one important thing end to end, including the parts around it that make it usable, so the lesson you learn is real rather than theoretical.

Why does multi-tenancy have to be decided so early?

Because it lives in the data layer, and the data layer is the hardest thing to change once you have customers in it. How tenants are isolated shapes almost every query, every permission check and every migration you will ever run. Retrofitting isolation into a product that already holds live customer data is slow, risky, and one of the most reliable ways to stall a growing SaaS — so we design it in before the first table exists.

Do you handle billing, or do we wire up a payment provider ourselves?

We build it as part of the product. That means the plans, proration, trials, dunning and tax or VAT handling your pricing actually requires, wired to a payment provider and connected to permissions so a plan change immediately changes what a customer can do. Billing touches revenue, so it is one of the places we are most deliberate — a subtle error here is money you have already earned and then lose.

What happens when we outgrow the first version?

That is the plan, not a surprise. We scale deliberately — watching where real load lands and reinforcing the part that actually buckles, which is usually the database and the way the team is organised rather than servers. Because you own the product and the roadmap, you can keep us alongside you for the scaling phase, bring it in-house, or do both; the code and the knowledge are yours throughout.

Building a SaaS product?

Start with a short, fixed-fee discovery: we will shape a real MVP, map the tenancy and billing, and give you a written, costed plan to build from.

Book a discovery call