SaaS development in Australia
ComplxAI is an Australian AI engineering and custom software development company. Our SaaS development work is multi-tenant products other businesses pay to use: tenancy, authentication, subscription billing, admin tooling and public APIs on AWS, with AI features designed into the first release.
- IP yours from the first paid stage
- Working software every couple of weeks
- Priced per stage, exit at any boundary
For founders and product teams building something to sell
A product sold to many customers carries obligations an internal tool does not: tenant data kept apart, invoices right every month, an API that keeps working.
Internal systems, portals and operations platforms for your own organisation are custom software development. Adding AI to a product you already run is AI feature development. Where the model is the product, see AI product development.
A good fit if…
- A validated idea that needs a version customers can pay for
- A services business ready to productise what it does for clients
- A product built for one customer that now has to serve fifty
- Billing, permissions or tenancy improvised early and now blocking growth
What SaaS development covers beyond the feature list
Customers buy features. Underneath sits the work a multi-tenant product cannot skip.
Tenancy and data isolation
Tenant identity travels with every request and query. Row-level policies, a schema or a database per tenant, chosen for your customers' size and compliance needs.
Authentication and roles
Cognito or equivalent, workspaces and invitations, single sign-on for enterprise plans, roles that mean the same thing in UI, API and database.
Subscriptions and billing
Plans, trials, seats and entitlements modelled in your own data and synced with a provider such as Stripe, so upgrades, failed payments and invoices reconcile without a spreadsheet.
Admin and support tooling
A console for your team: tenant configuration, plan overrides, refunds, feature flags and audited impersonation.
Public APIs and webhooks
Versioned REST APIs with keys, scopes and rate limits per tenant, OpenAPI docs, sandbox tenants and outbound webhooks with retries.
AI features designed in
Search, summarisation, drafting and classification inside the workflow, with tenant-scoped retrieval, evaluation and cost telemetry built in through our AI engineering practice.
A multi-tenant SaaS stack on AWS
Every customer shares this platform and none should be able to tell. Tenant context is set at the edge and carried through every service, query and queue; plans and entitlements live in your database and are mirrored to the payment provider. The account, network and cost side is our AWS consulting.
- Clientscustomer and staff surfacesWeb app (React/Next.js)Mobile appsAdmin consolePartner API
- Edge and identityentry and accessCloudFrontAPI GatewayCognitoSSO for enterprise plansAPI keys and scopes
- Applicationservices and jobsLambda or ECS/Fargate servicesTenant-context middlewareEventBridgeSQS queuesStep Functions
- Commerceplans and moneyPlan and entitlement modelStripe or similarUsage meteringBilling webhooks
- Dataper-tenant storageRDS/Postgres with row-level policiesDynamoDBS3 with tenant prefixespgvector
- AI layerfeatures and retrievalLLM APIs or BedrockRetrieval scoped to tenantModel routingEvaluation setsCost telemetry per tenant
- Operationsrun and observeTerraform/CDKCI/CDCloudWatchTracingAudit logProduct analytics
From idea to a product customers pay for
The five stages in how we work, applied to a SaaS build.
- ShapeDiscovery and Strategy, two to four weeks each: who pays, for what, what ships first, which tenancy and billing model.
- MVP in 12-week blocksWorking software every couple of weeks, each block priced before it begins. Scope is set around the thinnest release worth charging for, so sign-up and billing come early, not last.
- LaunchOnboarding, billing edge cases, support tooling, monitoring and a runbook, then the first paying tenants.
- ScaleUsage-driven blocks: performance, enterprise features, partner API, new plans, AI features, each priced upfront.
Four kinds of SaaS product we build
Vertical SaaS for an industry
A firm turns its own process into a product for its peers: workflow, documents, compliance and reporting for one sector.
B2B platform with a partner API
Customers who integrate rather than click: keys, scopes, sandbox tenants, versioned endpoints, webhooks. Luxpip pairs web and mobile apps with a B2B API.
Marketplace or booking product
Supply, demand, availability and payouts: matching, calendar rules, deposits, cancellations and admin tooling to referee disputes.
Replatforming an ageing product
A product that still sells but cannot take new features, moved tenant by tenant behind a compatibility layer so the old product keeps billing while the new one takes over. Starts with a software engineering consulting review.
MVP versus scale-ready
What we build first, and what it is designed to grow into.
| Concern | MVP | Scale-ready |
|---|---|---|
| Tenancy | Shared Postgres, tenant column, row-level policies. | Schema or database isolation for enterprise tenants, tenant-aware caching, per-tenant export. |
| Authentication | Email, magic link or social sign-in through Cognito; owner and member roles. | SAML/OIDC single sign-on, SCIM provisioning, granular permissions, MFA policies per plan. |
| Billing | A few plans, card payments and trials through the payment provider, reconciled by webhook. | Seats, usage metering, invoicing, tax, dunning, coupons, enterprise contracts outside the card flow. |
| Infrastructure | One AWS account, one region, infrastructure-as-code, CI/CD, preview environments. | Accounts per environment, multi-AZ data, autoscaling, disaster-recovery drills, status page. |
| AI features | One or two scoped features, tenant-limited retrieval, an evaluation set. | Model routing, per-tenant cost budgets, human review queues, evaluation gates in CI. |
Built for the security questionnaire that arrives before the contract
Larger customers ask before they sign: where data lives, who can see it, how access is logged, what happens when something fails. We build so those answers are easy to give.
Designed in from the first block
- Tenant isolation enforced by the database, not only the app
- Least-privilege IAM, secrets management, encryption at rest and in transit
- Audit log of admin actions, impersonation and API access
- Backups with point-in-time recovery, restores tested
- Deployed in the AWS region you need; for Australian data residency, that is the Sydney region
Shipped products, and how we work
SaaS we have shipped
A custom SaaS platform and admin panel built for Modedu; the client reports 2× revenue within six months and ARR of $400k → $1M.
APIs built for partners
For Luxpip we shipped web and mobile apps, an admin panel and a custom B2B API.
One team, end to end
Design, engineering, infrastructure and delivery sit with the same few senior people, remote across Australia and onsite when a launch needs it. The same team scaled QAL VPN to a global launch.
Yours to keep
Code, infrastructure and documentation are yours from the first paid stage. See what we've built.
Where SaaS work connects
AI product development
Products where the model is the offer.
AI SaaS product developmentCustom software development
Internal systems, portals and operations platforms.
Custom software developmentAI feature development
AI added to a product you run.
Adding AI features to a productAWS consulting
The platform underneath: accounts, data, cost.
AWS architectureSoftware engineering consulting
Architecture review before a replatform.
Architecture reviewAI engineering
Retrieval, evaluation and observability for in-product AI.
Production AI engineeringWho owns the code and the product?
You do, from day one of any paid stage. Repositories, infrastructure code, design files and documentation are set up in your accounts from the start, so there is nothing to hand back later.
Is building cheaper than subscribing to an off-the-shelf tool?
For your own operations, often not, and we will say so. A SaaS product is what you sell, so the question is margin and defensibility; Discovery settles it before any build is priced.
How long until customers can pay for it?
Discovery and Strategy take two to four weeks each; Implementation then runs in 12-week blocks with working software every couple of weeks. The plan names the block that carries sign-up and billing; each is priced before it starts.
What if we sign a customer ten times bigger than the rest?
The architecture is chosen with that customer in mind: stronger isolation, single sign-on, usage metering and separate environments are designed as additions to the MVP, not a rewrite of it. Anything beyond the plan is scoped and priced as its own block.
Can we take the product in-house later?
Yes. Documentation and handover are included in every stage, the stack is mainstream (TypeScript, Python, React, Postgres, AWS) and you can exit at any block boundary.
Have a product in mind, or one that has outgrown its first build?
Tell us who pays and what they get. The first two conversations are free; every stage after is priced in writing.