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
- SaaS Buy the standard AccountingPayroll
- Hybrid Buy the base, build on top ERP + custom integrationOps tool + client portalStore + B2B portalAI on tools you already pay for
- 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
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
- What you build Smaller and yours: the portal with your wholesale buyers’ prices and credit, your rules, your automations.
- One module Your code talks to the vendor from one place: switch tomorrow and you rewrite this piece, not everything.
- What the SaaS must offer A public, documented, versioned API, webhooks, usage limits that cover your volume and a full export.
- What you buy Whatever works the same in any company: the store, the ERP, the operations tool.
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.
| Criterion | SaaS | Custom | Hybrid |
|---|---|---|---|
| Time to go live | Shortest: sign up and configure | Longest, delivered in phases | The standard part runs from the start; your own layer arrives in phases |
| Fit with your process | You adapt to the software | The software adapts to you | Standard where it doesn’t set you apart, yours where it does |
| Upfront investment | Low | High | Medium |
| Ongoing cost | Licenses that grow with users or volume | Infrastructure and maintenance | Licenses for the standard part and upkeep for your own layer |
| Integrations | Whatever the vendor offers | Whatever you need | The vendor’s, plus the ones you build on its API |
| Data | On the vendor’s platform, with whatever export it allows | In your own database | Split: each piece of data needs a defined source of truth |
| Roadmap | Set by the vendor | Set by you | Shared |
| Exit | Depends on the contract and the export | With the code and docs in your name, you change teams, not systems | You replace one piece at a time |
| Main risk | Your process doesn’t fit, or the price grows faster than you do | Runaway scope and no one to maintain it | Changes 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.
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.