Roles and permissions
Organisation, team, and per-resource access that holds up when a customer has fifty employees.
Every SaaS product has two halves. The half you demo — the features that make it worth buying — and the half that makes it a business: tenancy, billing, roles, onboarding, support tooling, and analytics. The second half is where projects overrun, because it is invisible until it is missing.
We build both, and we build the second half properly the first time, because the two decisions that are most expensive to reverse — tenancy model and billing architecture — are both in it.
Multi-tenancy: the decision to get right early
| Model | How it works | Suits | Trade-off |
|---|---|---|---|
| Shared schema | One database, tenant ID on every row | Most B2B SaaS | Cheapest to run; needs disciplined query isolation |
| Schema per tenant | One database, a schema per customer | Mid-size B2B with data separation needs | Cleaner isolation; migrations get heavier |
| Database per tenant | Full separation per customer | Enterprise, regulated, or residency-bound | Strongest isolation; highest operational cost |
Most products should start with a shared schema and strict isolation at the data-access layer, with the option to promote large or regulated customers to their own database later. What you must not do is defer the decision — retrofitting tenancy is one of the most expensive rewrites in software.
Billing is not a Stripe integration
- Plans and limits enforced in the product, not just described on the pricing page.
- Proration on upgrades, downgrades, and mid-cycle seat changes.
- Failed payments and dunning — retries, notices, and a defined grace period before restriction.
- Trials with and without card capture, and the conversion path between them.
- Usage-based components metered accurately enough to defend on an invoice.
- Tax — VAT, GST, and sales tax handled through Stripe Tax or an equivalent.
- Invoices and receipts your customers' finance teams will accept.
- Revenue reporting that reconciles to what the payment provider actually settled.
What else we build
Onboarding
Guided setup, sample data, and an activation path — the single biggest lever on conversion from trial.
Admin and support tooling
Impersonation with audit logging, plan overrides, refunds, and usage inspection.
Integrations and API
A public API, webhooks, and an OAuth app model so customers build on you.
Audit logs
Who did what and when — increasingly a procurement requirement, not a nice-to-have.
Analytics
Activation, retention, and expansion measured from day one rather than reconstructed later.
Key facts
- Tenancy
- Modelled explicitly at architecture stage, with a documented promotion path
- Billing
- Stripe or a regional provider, with proration, dunning, and tax
- Security
- OWASP Top 10 review, tenant isolation testing, and audit logging
- Compliance readiness
- Access control, logging, and data export built for SOC 2 or ISO evidence
- Hosting
- Your cloud account, defined in Terraform and owned by you
- Ownership
- Full source code, infrastructure code, and documentation
Where SaaS builds go wrong
| Mistake | Cost when discovered late |
|---|---|
| Tenancy retrofitted after launch | Among the most expensive rewrites there is |
| Billing edge cases ignored | Revenue leakage and customer disputes |
| No admin tooling | Every support ticket becomes an engineering task |
| Permissions bolted on | Security incidents and blocked enterprise deals |
| No audit log | Failed procurement reviews at exactly the wrong moment |
| No analytics | No idea which feature drives retention |
Technology stack
We choose tools for what your team can maintain after handover, not for novelty. Typical stack for this service:
Next.jsNode.jsNestJSPostgreSQLRedisStripeDockerAWSTerraform
Questions, answered.
How do you handle multi-tenancy?
We choose the model deliberately at architecture stage — shared schema, schema per tenant, or database per tenant — based on your customer profile, isolation requirements, and data residency obligations, and we document a promotion path so a large or regulated customer can be moved to stronger isolation later without a rewrite.
Can you build subscription billing?
Yes, and it is more work than people expect. Plans, seat management, proration, trials, failed payment handling, dunning, tax, invoices, and revenue reporting that reconciles to actual settlements. We build on Stripe or a regional provider rather than writing a billing engine, because billing is a solved problem worth buying.
Is our platform ready for enterprise customers?
Enterprise procurement asks a predictable set of questions: SSO, role-based access, audit logs, data export, uptime commitments, and security review. We build those in from the start where enterprise is the target, because retrofitting them is what stalls deals that were otherwise won.
Can you scale it as we grow?
We architect for a realistic multiple of your expected load rather than for imagined web-scale traffic, since premature distribution is its own failure mode. That means proper indexing, caching, queued background work, and a clear horizontal scaling path when the numbers justify it.
Do we own the infrastructure?
Yes. It runs in your cloud account under your billing, defined in Terraform committed to your repository, with runbooks written for someone else to follow. You should be able to replace us without a rebuild — that is deliberate.
Can you take over an existing SaaS product?
Yes. We start with a paid audit of the codebase, data model, security posture, and infrastructure, and return a prioritised report separating the genuinely urgent from the merely untidy. You keep the report regardless of whether you continue with us.
You do not have to commit to a whole build.
Most people arrive somewhere between “just curious” and “ready to sign”. These are the smaller, fixed-fee ways in — each one useful on its own, and each one credited or extended into a bigger project only if you decide you want that.
Code & architecture audit
You have a codebase — inherited, stalled, or just worrying — and want an honest read before committing to anything.
- Written report on architecture, security, data model and deployment
- A prioritised list separating genuinely urgent from merely untidy
- A straight answer on repair versus rebuild, even when rebuild pays us more
- The report is yours whether or not you continue with us
Fixed fee, agreed before we start
Ask about this →
Scoping sprint
You know roughly what you want but not what it should cost or contain. Turn a vague idea into a specification you could hand to any supplier.
- Process mapping with the people who actually do the work
- A feature-by-feature written specification
- Wireframes of the core screens
- A fixed build price and delivery date at the end
- Fully credited against the build if you go ahead with us
Fixed fee, credited against the build
Ask about this →
Starter build
One workflow, one screen set, live and in use — rather than waiting on a full platform.
- A single working feature deployed to production
- Real infrastructure, not a prototype
- Extends into the larger build later without rework
- Full source code on delivery, as always
Fixed price, scoped small on purpose
Ask about this →
Maintenance retainer
An existing product that needs keeping alive: patches, OS updates, store policy changes and monitoring.
- Security and dependency patching
- iOS and Android release compatibility
- Uptime and error monitoring with a named response window
- An allowance of small changes each month
Monthly, 30 days' notice, no lock-in
Ask about this →
Not sure which fits? Describe the problem and we will tell you — including when the answer is that you do not need us yet.
Six things we put in writing.
Not values on a wall — contract terms. Ask any other supplier to match them line by line.
A price in 24 hours
Send a brief, get a fixed written price and a delivery date the next working day. Free, no obligation, and the scope document is yours to keep even if you go elsewhere.
The price does not move
Fixed, not an estimate. If scope changes we re-quote in writing and you approve before we build it. You will never open a surprise invoice.
Half on delivery
50% to start, 50% when it is live and you are satisfied. You never fund the whole project up front.
Unlimited design revisions
We do not write production code until you approve the screens. Changing your mind at that stage costs nothing.
You own everything
Full source code, design files and credentials on delivery. No licence, no platform fee, nothing that stops another developer taking over.
30 days of fixes included
Free bug fixing for a month after launch, then an optional retainer only if you want one.
Every one of these is in the agreement before you pay anything. See how we evidence our claims →
Free quote
Tell us what you're building.
A paragraph is enough to start. You get a scoping conversation and a fixed written price with a delivery date within 24 hours — free, and yours to keep whether or not you go ahead with us.
- A senior engineer replies, not a salesperson
- Written quote inside 24 hours
- NDA before you send anything sensitive — just ask
- No obligation, no follow-up sequence
Prefer to talk now? WhatsApp +92 300 097 0544 or hello@qalmax.com.
Build the half nobody demos.
Tenancy, billing, and permissions done right the first time. Quote in 24 hours.