Skip to content
CipherCruCipherCru

Menu

Web Development

SaaS Web App Development

The parts of a SaaS product that do not demo well but decide whether it can be sold: tenancy, roles, billing and an audit trail.

Typical duration
Eight to fourteen months
Team shape
Three to five senior engineers
Starts with
A three-week diagnostic
An admin dashboard showing account and usage views

The features that decide whether you can sell it

A SaaS product usually fails its first enterprise procurement review on the surfaces nobody prioritised: who can see what, who changed it, and how the invoice was calculated.

Nobody builds a product for its permissions matrix. The features that win a demo are the ones a founding team can picture, and tenancy, roles, billing and audit get deferred because no customer has asked for them yet. Then one does, and it does not arrive as a feature request: it arrives as a security questionnaire with a signature waiting behind it. Retrofitting isolation into a data model that quietly assumed one customer is the most expensive work in SaaS, and it lands at exactly the moment the business can least afford to stop shipping. So we put it in the first migration, when it costs a schema decision rather than a rewrite.

What usually goes wrong, and what we do instead

The pattern is consistent enough that we now design for it from the first sprint.

Where SaaS builds get stuck

  • Tenancy bolted on after launch, so isolation cannot be proven
  • Roles that fit the founding team and nobody else
  • Billing logic spread across three services and a spreadsheet
  • No audit trail, discovered during a security questionnaire
  • A single-tenant assumption buried in the data model

How we build it instead

  • Tenancy in the data model from the first migration
  • Roles and permissions modelled before the first admin screen
  • One service that owns billing, with everything else reading from it
  • Every write attributable and exportable, from the start
  • A security questionnaire answered before it is asked

What we build

The surfaces a SaaS product needs before it can be sold upmarket.

Multi-tenancy

Isolation you can demonstrate to a security reviewer, not just assert.

Roles and permissions

Configurable per tenant, so one customer's structure does not become everyone's.

Billing and metering

Usage that reconciles with the invoice, and an invoice you can explain.

Audit trail

Every write attributable, queryable and exportable.

Admin and reporting

The console your own team uses to support customers without a database client.

Onboarding and provisioning

A new tenant created without an engineer in the loop.

What you end up with

Stated from your side rather than ours.

  • A product that passes procurement

    The access, audit and isolation questions answered before they are asked.

  • Support without engineering

    Your support team resolves tenant issues from an admin console, not a ticket to us.

  • Billing you can defend

    Every line on an invoice traces back to a metered event.

  • A codebase your team can extend

    Documented decisions, tested paths, and infrastructure in accounts you own.

How the build runs

The same five stages as every engagement, applied to a SaaS product.

Diagnose

Who the buyer is, what procurement will ask, and what the data model has to carry.

Decide

Tenancy model, permission model and billing approach, written down with the trade-offs.

Prove

One tenant, one role, one metered event, end to end in production.

Deliver

Surfaces built in slices, each live before the next is scoped.

Hand over

Your team runs it with us watching, then without us.

What we build it with

Chosen for what a multi-tenant product has to prove, not for novelty.

Interface

  • TypeScript
  • React
  • Next.js
  • Tailwind CSS

Services

  • Node.js
  • Spring Boot
  • GraphQL
  • REST
  • Temporal

Data

  • PostgreSQL
  • Row-level security
  • Redis
  • Prisma
  • Supabase

Platform

  • AWS
  • Terraform
  • Docker
  • Kubernetes
  • GitHub Actions

What you get, and when

Handed over as it is produced, not assembled at the end.

  • A tenancy and permission model, written down
  • A billing approach with its trade-offs
  • A procurement readiness assessment
  • Source in repositories you own
  • Infrastructure as code, in your accounts
  • A tested rollback path per release
  • Audit trail schema and retention policy
  • Isolation test results
  • A completed security questionnaire template

Where we have built this

Sectors where we have shipped multi-tenant products into procurement review.

A banking hall desk where a laptop shows an account dashboard with a running balance, recent transactions and a monthly activity chart, a phone beside it

Fintech & BFSI

Secure, reliable systems for businesses built on trust.

We build and modernize financial platforms, workflows, integrations, and customer-facing applications where reliability, data integrity, auditability, security, and performance are fundamental to the business.

A clinician talking with a patient at the bedside while a monitor shows that patient's record - vitals, scans and recent reports - with the same case open on a phone

Healthcare

Technology that connects complex care and operational workflows.

We help build digital healthcare platforms, operational workflows, integrations, and data-driven applications designed around reliability, secure information handling, usability, and the realities of interconnected healthcare systems.

An open-plan office with a laptop showing a workforce dashboard - headcount, attendance, leave requests and approvals - and the same modules on a phone

HRMS

Workforce systems built around how organisations actually operate.

We build and improve workforce platforms spanning recruitment, onboarding, employee management, attendance, operational workflows, reporting, and integrations, reducing friction across the employee lifecycle.

A lecture room seen from the back, a laptop in the foreground playing a course video beside its numbered module list, the same course open on a phone

EdTech & eLearning

Learning platforms designed around engagement and scale.

From learner journeys and course delivery to assessments, administration, analytics, and integrations, we develop education platforms that make learning experiences easier to operate, evolve, and scale.

Questions about SaaS builds

The ones we are asked most often before a first conversation.

We already have a product. Can you retrofit tenancy?
Usually, and it is common work, but it is a data problem before it is a code problem. The first job is finding where the single-tenant assumption is buried: a table with no tenant key, a cache key without one, a background job that queries across everything, a report written against the whole database. We map those, agree what isolation will actually mean once it is in place, and stage the migration so the product keeps shipping while it happens. What we will not do is add a filter in the application layer and call it isolation. That version demos well and fails an audit.
Do you build billing or integrate a provider?
We integrate a provider for payments, invoicing and tax, because that is a regulated surface that changes without asking you and you should not own it. What we do build is the metering: the record of what each tenant used, held in your own system, which the provider’s invoice is generated from and can be reconciled against. That split is what matters when a customer disputes a line on an invoice, because the answer then comes from your data rather than from a dashboard you do not control.
Can you get us through SOC 2 or ISO 27001?
We are not auditors, and no engineering firm can certify you. What we can do is build so the evidence exists as a by-product: access control that is modelled rather than improvised, an audit trail that can be queried and exported, change management that falls out of the pipeline instead of a spreadsheet, and written answers to what both frameworks ask about how the system is operated. Most of the pain in a first certification is reconstructing that evidence after the fact for a system never built to produce it. You will still need an auditor, and you will still need policies describing how your company works.
How many tenants can this handle?
That depends far more on what a tenant does than on how many there are, so the honest answer is that we size it against your real usage profile rather than quote a number in a proposal. What we design in from the start is the ability to change the answer: tenancy in the data model, the noisy-neighbour cases understood, and the parts most likely to need separating identified before the day they do.
Some customers want single-tenant. Is that possible?
Yes, and it is worth deciding early, because the expensive version of this is discovering it after launch. Where a dedicated instance is likely to be part of a deal, we keep the deployment single-tenant-capable from the start: same schema, same configuration, same pipeline, whether one tenant is running behind it or a thousand. What we will not do is fork the codebase for one customer. A second copy diverges within a release or two, and after that every fix costs twice.
What happens after launch?
The access and audit surfaces are the ones that keep moving, because each new enterprise customer asks something the last one did not. Your team has been running the product alongside us since the first slice, so those changes are theirs to make, and how much of our time you want beside them is agreed separately.

Building a SaaS product that has to sell upmarket?

Tell us who the buyer is and what procurement will ask. We will tell you what has to be true before you get there.

Strictly necessaryEssential for the site to function: page navigation, security, session management, and remembering the cookie choices you make here.
Always on
FunctionalRemembers choices you make, such as language, region or display preferences, so the site opens the way you left it.
Performance and analyticsPerformance and analytics cookies show us how the Website is used: which pages are visited, how long is spent on them, where visitors came from, and what errors occur. They are set by Google Analytics and by HubSpot, whose cookies also link the pages you viewed to any enquiry you later send us.
Marketing and targetingTracks browsing activity to measure advertising and show relevant ads. We set none of these today, and will not without your opt-in.