SaaS Architecture Mistakes We Made So You Don’t Have To

SaaS architecture mistakes involving database selection, risk separation, and third-party dependencies.
Software Development 6 min read

The SaaS architecture mistakes that cost real money are rarely the ones the conference talks warn about. Ours were choosing a database for familiarity instead of workload, running structurally different customer classes through one shared architecture, and trusting third-party capabilities without checking their lifecycle. And one honest surprise: raw scaling, the fear that sells most architecture consulting, has barely been a failure class for us at all.

On this page

Mistake one: the database we knew best

We built the first version of our recruitment platform on MongoDB because we knew it deeply. At 180,000 candidates with heavily relational access patterns (queries, joins-by-another-name, indexing, search), it became slow and expensive, and we migrated to PostgreSQL for the second version. The mistake was not MongoDB; it was the selection criterion. Choose for the queries you will run at scale, not the tools your team is comfortable with. Comfort is a real cost saving at week one and a real liability at year two.

Mistake two: one architecture for two different risk classes

On a creator platform we operated, structurally different creator classes, standard creators and high-risk categories, ran through substantially shared architecture and payment flows. Payment providers do not treat those classes alike, and when processor policy turned against the high-risk class, the shared architecture meant a policy change aimed at one customer class exposed unrelated customers to the same dependency. The lesson generalizes past creator platforms: when your customers differ in regulatory or risk profile, that difference belongs in the architecture (separated flows, separable providers, isolatable exposure), not just in the terms of service.

Mistake three: assuming vendor capabilities have your lifecycle

Our hardest integration saga included a required capability that a major processor had quietly sunset for new accounts, and a second provider that refused our use case outright. The due-diligence rule that came out of it: verify that a third-party capability is available to you, for your use case, on new accounts, in writing, before the architecture depends on it. Documentation describes the past; sales calls describe the ideal; your account is neither.

What the database mistake actually looked like, mechanically

The abstract lesson is “choose for the workload.” The concrete version is more useful. An ATS workload is join-heavy by nature: every screen answers a question like “candidates with this skill, submitted to this client, in this stage, touched by this recruiter, in this date range.” In a document database, each of those questions either denormalizes into duplicated data that must be kept consistent by application code, or resolves through multiple round trips that get slower as collections grow. At 180,000 candidates plus their interactions, both costs arrived at once: queries that crossed entities got slow, indexes multiplied to compensate, and the infrastructure bill grew faster than the data. PostgreSQL didn’t win because it is fashionable; it won because joins, constraints, and query planning are exactly the work this product does all day. The test to run on your own choice: write down the ten questions your product’s screens will answer at ten times your current data, and ask whether your database answers them natively or through application-code gymnastics. Gymnastics compound.

What risk-class separation would have looked like

The creator-platform lesson has a concrete counterfactual worth spelling out. Separation would have meant: distinct merchant accounts or providers per risk class from day one, payment flows that could be modified per class without touching the other, and data models that let one class’s rules evolve independently. The cost of that separation at design time was modest, a few weeks of additional structure. The cost of its absence arrived years later as provider policy risk that couldn’t be contained to the class that triggered it. The general form: whenever two customer groups differ in how a regulator, bank, or platform treats them, that difference eventually becomes an operational event, and your architecture either contains it or spreads it.

How to audit your own architecture in one afternoon

Four questions, in order. One: list your top ten query patterns and ask whether your database answers them natively. Two: list your customer classes by risk profile (regulatory, payment, content) and check whether a policy change against one can be contained. Three: list every third-party capability your architecture depends on, and verify each is available to new accounts for your use case, in writing. Four: write down the largest workload your current design has actually survived, not the one it theoretically handles. The gap between question four’s answer and your growth plan is your real architecture backlog, and it is usually shorter and different than the rewrite a vendor will propose.

The mistake we keep not making: scaling panic

Here is the counter-narrative our history supports. Across years of operating consumer and B2B products, raw scale has produced one notable capacity incident, resolved with a server upgrade. Meanwhile database fit, risk architecture, and vendor dependency produced migrations, redesigns, and lost months. Founders buy architecture for the traffic spike they dream of and underbuy it for the workload shape they already have. Looking back, none of our expensive mistakes were really technology mistakes. They were classification mistakes: we misunderstood the workload, the risk boundary, or the lifecycle of something we depended on. Design for your access patterns, your risk classes, and your vendors’ realities; the load balancer can usually wait.

FAQs

Which database should a SaaS start with?

The one that answers your real query patterns natively. For join-heavy, constraint-heavy business workloads that is usually a relational engine; for genuinely document-shaped data it may not be. The wrong answer is "the one we know," which is the mistake we made.

Is migrating databases later really that bad?

It is a project, not a catastrophe: ours happened alongside a version rebuild and was grounded in operating knowledge. But it is far more expensive than choosing correctly, and it arrives exactly when the product is busiest.

How do I know if my architecture has a risk-class problem?

If a payment provider, platform, or regulator changed policy toward your riskiest customer segment tomorrow, could you comply for that segment without touching the others? If not, the classes are coupled.

Do I need microservices to avoid these mistakes?

No. None of the three mistakes above is about service topology. A well-structured monolith with the right database, separated risk classes, and verified vendor dependencies beats a microservice architecture with none of them.

Making architecture calls on a SaaS right now? Tell us the workload and the customer mix; we’ll flag which of these mistakes it’s closest to:

Work with us

Building something that cannot afford to break?

Book a Strategy Call

Leave a comment

Your email address will not be published.