Articles

Custom software 9 min read

Custom software vs SaaS: when to build and when to buy

Custom software vs SaaS, without the sales pitch: a build vs buy framework, what total cost of ownership includes and the signs you shouldn’t build.

André Valle Ortega Founder, Flouvia

Sooner or later, every established company hits the same question: do we keep bending our process around a tool we rent, or do we build custom software? We’re a studio that designs and builds custom software, and our answer is still often to buy. This is the build vs buy framework we use, including the signs that you shouldn’t build at all.

The useful question isn’t which option is better. It’s which part of your operation is standard and which part is yours. Accounting and payroll work much the same in any company. The way you quote, fulfill or serve your clients may be the reason they choose you, and that’s where a generic product forces you to operate like everyone else.

One disclosure before we start: Flouvia builds custom software and also runs its own SaaS, Cord. We see this decision from both sides.

What to buy and what to build

Same in any company · Fits the product

  1. SaaS Buy the standard AccountingPayroll
  2. Hybrid Buy the base, build on top ERP + custom integrationOps tool + client portalStore + B2B portalAI on tools you already pay for
  3. Custom Build what sets you apart Per-client pricing and creditHow you quoteFulfillment times

The reason clients pick you · Your own rules, integrations and volume

What to buy and what to build. Whatever works the same in any company gets rented, whatever makes clients pick you gets built, and the hybrid route fits in between.

When SaaS wins

SaaS (software as a service) is a product you rent on a subscription: the same system for every customer, hosted, maintained and updated by the vendor. It wins when:

  • Your process is standard. If you can describe it in the words any vendor in your category uses, someone has already built it and will maintain it for you.
  • Volume is low. With few users, transactions and exceptions, the subscription will most likely cost less than maintaining a system of your own.
  • You need it now. A SaaS gets signed and configured; a system of your own, even in phases, has to be designed and built.
  • You’re still figuring out the process. Renting first teaches you what you need before you invest.

Signs you shouldn’t build

  • What bothers you is the interface or a couple of fields, not the process. That’s fixed with configuration.
  • You want your own software because it sounds like an asset, not because of a specific problem.
  • There’s no budget to build it and then keep it running: custom software is never a one-time payment.
  • Nobody in the company can define rules, review progress and test. Without that owner, no studio can build it well.

If any of these sound familiar, or none of the conditions below apply to you, buy.

When custom software wins

Custom software is designed and built around one company’s process, with the code and the data under its control. Any one of these conditions can justify it, and the case gets stronger when several show up.

Your process is your edge

If clients pick you for how you quote, how fast you ship or how you look after each account, that process is part of what you sell. Squeeze it into a generic product’s mold and you run the same playbook as every competitor renting the same tool.

Integrations the SaaS can’t handle

Your ERP, your store, your warehouse and your clients’ systems need to talk to each other. Generic connectors tend to sync fields, not rules: they copy an order across, but they don’t know that this client buys on credit, at their own price, from another warehouse. If you integrate today with exports and double entry, you’re already paying for it in your team’s hours.

Per-seat pricing that grows with your team

Many SaaS products charge per user: the bill rises with every hire and multiplies once you give access to distributors, clients or field sales reps. A system of your own costs infrastructure and maintenance, not seats. It isn’t free: it changes the shape of the cost, and the math is worth doing.

Data and rules that don’t fit

Per-client pricing, credit terms, approval flows, taxes across several countries. Once custom fields and side spreadsheets are the real system, the SaaS is just the front door.

You want to own the code and the data

If software sits at the center of your operation or is part of what you sell, its roadmap, its data and its security need to be your call, not the outcome of a vendor’s next pricing change.

It happened on our own site: the contact form ran on a third-party automation tool, and we moved it to our own code once it became critical. The tool wasn’t the problem; the flow could no longer live outside our codebase.

Buy what makes you the same as everyone else; build what makes you different.

The hybrid route: buy the standard, build on top

Between renting everything and building everything, the sensible move is often to combine: a SaaS for whatever works the same in any company, and a smaller layer of your own for what’s yours. For example:

  • A Shopify Plus store with your own B2B portal where wholesale buyers order at their prices and on their credit.
  • An off-the-shelf ERP with a custom integration that moves orders, inventory and prices by your rules.
  • An operations tool with a client portal built on its API.
  • AI automations in your own code on top of the tools you already pay for.

Cord can be used this way: it covers the B2B sale from quote to payment and invoice, and exposes a REST API, signed webhooks, an MCP server and Cord Elements, the quote builder you embed in your own site, so your portal or ERP can use it without rebuilding it. It also shows that the line moves: it started as the quoting system of a custom B2B portal for a wholesale distributor, became a Shopify app and, since June 2026, has been an independent product.

For a hybrid to work, the SaaS has to let you build on it: a public, documented, versioned API, webhooks, usage limits that cover your volume and a full export of your data. And your own layer should talk to the vendor through a single module in your repository: if you switch tomorrow, you rewrite that piece, not everything.

The hybrid route, in layers

  1. What you build Smaller and yours: the portal with your wholesale buyers’ prices and credit, your rules, your automations.
  2. One module Your code talks to the vendor from one place: switch tomorrow and you rewrite this piece, not everything.
  3. What the SaaS must offer A public, documented, versioned API, webhooks, usage limits that cover your volume and a full export.
  4. What you buy Whatever works the same in any company: the store, the ERP, the operations tool.
The hybrid route: the standard part bought at the bottom, your layer on top and a single module between them. Switch vendors and you swap that piece.

Custom software vs SaaS vs hybrid, side by side

The same decision as a table. No column wins every row; what matters is which rows weigh most in your operation.

CriterionSaaSCustomHybrid
Time to go liveShortest: sign up and configureLongest, delivered in phasesThe standard part runs from the start; your own layer arrives in phases
Fit with your processYou adapt to the softwareThe software adapts to youStandard where it doesn’t set you apart, yours where it does
Upfront investmentLowHighMedium
Ongoing costLicenses that grow with users or volumeInfrastructure and maintenanceLicenses for the standard part and upkeep for your own layer
IntegrationsWhatever the vendor offersWhatever you needThe vendor’s, plus the ones you build on its API
DataOn the vendor’s platform, with whatever export it allowsIn your own databaseSplit: each piece of data needs a defined source of truth
RoadmapSet by the vendorSet by youShared
ExitDepends on the contract and the exportWith the code and docs in your name, you change teams, not systemsYou replace one piece at a time
Main riskYour process doesn’t fit, or the price grows faster than you doRunaway scope and no one to maintain itChanges to the vendor’s API

What total cost of ownership includes

Comparing a SaaS subscription with a project quote means comparing two different things. Total cost of ownership adds up everything you pay, in money and in hours, over the life of the system:

  • Licenses. Per user, per volume, per module or per API call. Today’s price matters less than its curve: what it looks like with twice the team or twice the orders, and what changes at each renewal.
  • Implementation. Configuration, data loading and training. It costs on a SaaS too, even if it never shows up on the vendor’s invoice.
  • Integrations. Connectors, middleware or custom development, plus upkeep every time either side changes its API.
  • Maintenance. On a SaaS the vendor handles it, but your configuration and integrations are still yours. On your own system it covers infrastructure, security, dependencies and improvements: a recurring cost, not a one-time payment.
  • Migration. Getting data out of the current system, cleaning it and moving it without stopping the operation.
  • Exit. What it costs to leave: contract terms, data export and whatever you’d have to rebuild. It’s the cost people tend to forget on the way in.
  • Your team’s time. Double entry, side spreadsheets and workarounds. It never shows up on an invoice, but you pay it every week.

Run the numbers for all three paths over several years, and for the operation you expect to have, not the one you have today.

Cumulative cost of the three paths

Illustrative, no figures: an operation that grows every year

  • SaaS Licenses that grow with users or volume
  • Hybrid Licenses for the standard part, upkeep for your layer
  • Custom Upfront investment in phases, then infrastructure and upkeep

Where they cross depends on your operation.

Each curve adds up licenses, implementation, integrations, maintenance, migration, exit and your team’s time.

An illustrative example, with no real figures: the shape of each cost over time. Compare the total over several years, not the first invoice.

The risks of building, and how to contain them

Building carries real risks. None of them disappear, but all of them can be contained:

  • Scope that never ends. Contain it with phases: first, a version that fixes the process that hurts most, in your team’s hands as early as possible; then the next piece, each with its own deliverable and definition of done.
  • Depending on whoever built it. Contain it with ownership: code in your repository from day one, documentation kept current, technical decisions in writing and technology other teams know. Put it in the contract.
  • Nobody maintaining it. Decide before you start: your own team, the studio on a maintenance plan, or another team with the documentation in hand. A system without an owner decays.
  • Rebuilding what already exists. Custom doesn’t mean from scratch: payments, email delivery or maps come in as pieces from specialized vendors.
  • Your team not adopting it. Contain it by designing with the people who will use it, testing with real cases and migrating in stages.

That’s how we work at Flouvia: in phases, with the repository and the documentation yours from day one. What we design and build is in Services. If you have a specific case and want a second opinion, write to us; if the answer is to buy, we’ll tell you.

Frequently asked questions

  • What is custom software?
    Software designed and built around one company’s process, with the code and the data under its control. A SaaS, by contrast, is a standard product you rent on a subscription, the same for every customer.
  • When shouldn’t you build custom software?
    When your process is standard, volume is low, you need it right away, or there’s no budget or people to maintain it. In those cases, a well-configured SaaS is the right call.
  • Is custom software more expensive than SaaS?
    The upfront investment is higher. Over several years, it depends on how licenses grow, what integrations cost and what each path takes to maintain: compare total cost of ownership, not the first invoice.
  • Can I start with a SaaS and build later?
    Yes, and it’s often the right order: the SaaS teaches you how your process works. From day one, make sure you can export all of your data.
  • What happens if the studio that built it stops working with me?
    If the repository, the documentation and the access are in your name, another team can pick up the system and keep going. Agree on it in the contract before the first line of code.

Written by

André Valle Ortega

Founder, Flouvia

André Valle Ortega is the founder of Flouvia, the design and engineering studio that builds made-to-measure websites, stores, portals, apps, platforms and automation.

LinkedIn