Most SaaS products that struggle do not fail because the code was bad. They fail because a few early decisions were made by accident: who the product is for, how customers are kept apart, how people sign up and pay, and what goes in the first release. Each of those is cheap to decide before development starts and expensive to change afterwards.
This guide walks through those decisions in the order they need to be made.
Start with one customer and one job
The most common mistake in a first version is breadth. A product that does ten things halfway is hard to sell, hard to support and hard to change. A product that does one job completely, for one kind of customer, gives you something to charge for and something to learn from.
Write down three things before anything else:
- Who the first customer is. Not a market — a person in a role, at a type of business, with a problem they already spend money on.
- The one job the product does for them. Described as the outcome they get, not the features you build.
- What they use today. A spreadsheet, a competitor, a manual process. That is what your product has to beat, and it sets the bar for version one.
Everything after this is easier when these three are written down, because every feature can be tested against them.
Decide how customers are kept apart
A SaaS product serves many customers from one running system. How each customer’s data is kept separate — the tenancy model — is the decision the rest of the architecture rests on.
There are three common approaches: a shared database where every record carries a customer ID, a separate schema per customer, or a separate database per customer. They trade cost against isolation, and the right one depends on who you sell to. Smaller customers who sign up on their own usually suit a shared model; larger or regulated customers may require their own database.
Two rules hold whichever model you pick:
- Enforce separation in the data layer. If keeping customers apart depends on every developer remembering to add a filter, it will eventually fail.
- Leave room for the exception. Even a shared platform should be able to give one customer a dedicated database without forking the codebase.
We go deeper on the trade-offs, and on moving an existing product to this model, on our SaaS Ready Platform page.
Retrofitting customer separation after launch is one of the most expensive changes a SaaS product can face. Decide it before the first table is created.
Plan sign-up, plans and billing as product features
In SaaS, how a customer starts and pays is part of the product, not an afterthought for later:
- Sign-up and onboarding. Can a customer create an account and get value without talking to anyone? If not, every new customer costs you staff time.
- Plans and limits. If a plan caps users, records or usage, the product has to enforce the cap and handle the upgrade.
- Billing. Subscriptions, trials, upgrades, failed payments and cancellations all need a path through the product.
- Accounts and roles. Businesses buy for teams. Accounts that belong to a company rather than a person, invitations and role-based permissions are usually needed early.
Larger customers will also ask for single sign-on. It does not have to be in version one, but the account model should not make it hard to add.
Choose an architecture you can change
A first version does not need to be built for a million users. It needs to be built so that it can change without a rewrite when you learn what customers actually do. In practice that means:
- A clear separation between the parts of the system, so one can change without breaking the rest.
- Automated tests that run against every change, so moving fast does not mean breaking what already works.
- Hosting that can grow, with monitoring in place from the first release rather than after the first outage. Our cloud development team sets this up as part of the build.
- An API from the start if customers will want to connect your product to the systems they already run.
The stack itself matters less than these properties. Pick technology your team can hire for and support for years, not the newest option.
Scope version one honestly
With the decisions above made, the first release becomes easier to scope:
- The core job, done completely for the first customer.
- The SaaS foundation: accounts, customer separation, sign-up and billing.
- The integrations the first customer cannot work without — and no others yet.
- The admin tools your own team needs to support customers.
Everything else goes on a list for after launch, in the order real customers ask for it.
Build, launch, then measure
Launch is the start of the real work. Plan for it before you build:
- Decide what you will measure: sign-ups that become active accounts, how often customers use the core feature, and where they stop.
- Keep the same team after launch. The people who built the product understand why it works the way it does, and changes are faster and safer in their hands.
- Release small changes often, backed by the tests built in from the start.
Our Fynancial case study shows what this looks like in practice: an advisor platform with a web app and a mobile app built in parallel on one API, designed so new integrations are a connector rather than a rebuild.
Where to start
Write down the first customer, the one job and what they use today. Then decide how customers will be kept apart. Those two steps settle more of the build than any technology choice. If you want a team to take it from there, our SaaS development service starts with exactly this conversation and ends with a written scope and a fixed quote.
