SaaS development

Build the version your next customer needs, not the one that demos well

We design and build subscription software — tenancy, billing, roles and onboarding included — in stages, so each release has a commercial reason to exist.

  • Tenancy decided before the first table
  • Billing treated as product, not plugin
  • Cut line agreed before the build
  • Your accounts, your code

Written scope and a fixed estimate within two business days. NDA on request.

Product stages

  1. 1

    MVP0 → first paying users

    The smallest product that proves the core job. One plan, manual onboarding if needed, no billing portal until someone actually pays.

  2. 2

    ProductFirst customers → repeatable sales

    Self-serve accounts, subscription billing, roles, and the reporting customers ask for in every sales call.

  3. 3

    ScaleGrowth → operating cost pressure

    Tenancy isolation, background jobs, usage metering and the observability that keeps support load down as accounts multiply.

Three stages

What belongs in each release

Scope creep is the normal failure mode of SaaS builds. Naming the stage keeps the release honest.

0 → first paying users

MVP

The smallest product that proves the core job. One plan, manual onboarding if needed, no billing portal until someone actually pays.

First customers → repeatable sales

Product

Self-serve accounts, subscription billing, roles, and the reporting customers ask for in every sales call.

Growth → operating cost pressure

Scale

Tenancy isolation, background jobs, usage metering and the observability that keeps support load down as accounts multiply.

Commercial readiness

What separates a demo from a product you can invoice for

ConsiderationPrototypeSellable product
Plans and billingInvoiced by handStripe subscriptions, proration, dunning
OnboardingA call with the founderSelf-serve with an invite flow
Access controlEveryone is an adminRoles, invitations, audit trail
Tenant dataShared tables, filtered in codeExplicit tenancy with enforced scoping
Support loadGrows with accountsUsage visibility and self-serve settings

Multi-tenancy

The checks we run before a second tenant signs up

  • Tenant ID on every row, with scoping enforced at the data layer rather than in each query
  • Row-level security or equivalent tested with a cross-tenant access attempt
  • Per-tenant limits for seats, storage and API usage
  • Subscription state checked server-side before gated features run
  • Webhook handling that is idempotent and replay-safe
  • Admin tools for support staff, with actions logged

Engagement

How we usually work together

New product build

Discovery, design and delivery of a first release — with a cut line agreed up front so the launch date is real.

Platform extension

Billing, roles, reporting or an API added to a product that already has users and cannot pause for a rewrite.

Rescue and stabilise

A codebase that shipped fast and now hurts: security gaps, test coverage, tenancy bugs and a deploy nobody trusts.

Delivery

Five steps from discovery to first cohort

  1. 01

    Discovery

    The customer, the job they hire the product for, the plan structure and the one workflow that must be excellent.

  2. 02

    Architecture

    Tenancy model, data shape, auth and billing decided early — these are the choices that are expensive to reverse.

  3. 03

    Build the core

    The primary workflow end to end, with real accounts and real billing in a test environment.

  4. 04

    Harden

    Access checks, rate limits, backups and the admin tooling support will need on day one.

  5. 05

    Launch and learn

    Onboard a small cohort, watch where they get stuck, then fix that before adding surface area.

Stack

What we build SaaS with

Frontend

  • Next.js
  • React
  • TypeScript

Backend

  • Node.js
  • Python
  • REST / tRPC

Data

  • PostgreSQL
  • Redis
  • Object storage

Operations

  • Stripe
  • Auth
  • CI/CD + monitoring

Proof

SaaS platforms we built and still support

SurveySlack runs multi-tenant surveys with roles and billing. TriviaMaker turned a free quiz builder into a $25K MRR product reported by the client — read the full case study.

FAQ

SaaS questions before you commit

How long until we have a sellable product?

A focused MVP is typically 8 to 14 weeks. “Sellable” usually depends less on features than on billing, onboarding and account management being complete enough that a customer can pay without a call with you. We scope those explicitly.

Should we build multi-tenant from day one?

Yes, the tenancy model should be decided on day one even if the first customers are few. Retrofitting tenancy into a product with live data is one of the most expensive changes a SaaS team can make.

Can you work with our existing codebase?

Yes. We start with an audit of the tenancy, auth, billing and test coverage, then give you a ranked list of risks with effort estimates before committing to a build plan.

Do you build the billing and subscription side?

Yes — Stripe subscriptions, plans, proration, trials, dunning and webhooks. Billing is treated as part of the product, not an integration bolted on at the end.

Who owns the code and the infrastructure?

You do. Repositories, cloud accounts and third-party billing accounts are created in your name with us as collaborators, so there is no dependency on us to keep operating.

Request a quote

What does your first paying customer need?

Describe the customer, the job your product does and how you plan to charge. We will scope the release that gets you to revenue, and say what can wait.

No obligation. We will tell you if we are not the right team for the job.

  1. 1

    Tell us the goal, platforms and must-have features.

  2. 2

    We reply within two business days with scope, approach and a fixed estimate.

  3. 3

    Sign an NDA first if you prefer — nothing about your idea is public.