Buy vs build a whitelabel SaaS — the cost math

You want to sell a small SaaS — a QR generator, a link shortener, a forms tool, a scheduler — and you're stuck on the same fork everyone hits. Pay $300–$5,000 for a whitelabel reseller license and ship in a weekend, or write the thing yourself over three to nine months of evenings. Most posts on this question handwave it into a vibe. The honest answer comes down to four numbers: your hourly opportunity cost, the license fee, the months until first paying customer, and how long you'll stay in the niche.

By the end of this you'll know which column your situation lands on. Not because someone told you to "follow your passion", but because the spreadsheet did the talking. If you haven't decided whether selling a SaaS is even the right side hustle for you, the broader side hustle ideas for non-developers ranks the alternatives first.

The buy path — what reseller listings actually include#

A reseller license for a whitelabel SaaS typically runs $300 to $5,000 as a one-time fee, with extended-license tiers that bump the price for unlimited end customers. The market for this kind of license sits mostly on CodeCanyon (which lists tens of thousands of scripts and SaaS templates) and a handful of dedicated whitelabel marketplaces. What you get for the money:

• Source code — usually PHP/Laravel or Node, sometimes a Vue/React frontend
• A self-hosted install path (you provide the server)
• Six to twelve months of bug fixes and minor updates from the original author
• The right to rebrand and resell to your own customers

What you do not get:

• A working hosting setup (the install runs on your hardware)
• Payment processing — you wire your own Stripe account
• Custom domain TLS automation in most cases (a meaningful gap if you sell to customers who want their own subdomains)
• Anyone to call when production breaks at 2am
• A roadmap you control — you ride whatever the original author ships next

That last point — six to twelve months of updates, then silence — is where buyers get burned. You're not buying software, you're renting confidence in the seller's continued attention. Pick a vendor whose business model is selling licenses (continuous revenue) over one whose business model was selling licenses once (a project they're now bored of).

The build path — what nine months of evenings looks like#

Building from scratch is the opposite trade. The cash outlay is small — domain ($12), server ($5–20/month), email transactional plan ($0–20/month), a Stripe account (free until you take payments). The real cost is your time, and developers chronically underestimate how much they spend.

A realistic build budget for a working whitelabel SaaS — not a side-project demo, an actual product that handles signups, billing, custom domains, multi-tenancy, and basic analytics:

• Auth + account management: 3 weeks evenings (signup, login, password reset, sessions)
• Core feature (links, QR, whatever your thing is): 4 weeks
• Multi-tenant data isolation: 2 weeks (this is the part developers always lowball)
• Billing integration: 2 weeks (Stripe Checkout, webhooks, plan-change flows, retries)
• Custom domain + TLS issuance: 2 weeks (a Caddy on-demand setup or LetsEncrypt automation)
• Basic admin tools: 2 weeks (you need to debug your own platform)
• Marketing site + docs: 2 weeks
• Production hardening: 2 weeks (monitoring, backups, the things you only think about after you've shipped)

That's nineteen weeks at maybe ten hours a week — call it twenty-six weeks of calendar time, six months. If your hourly opportunity cost is $40 (a freelance rate, or what you give up by not taking a side gig), that's $7,600 in unpaid labour. At $80/hour it's $15,200. At $150/hour (senior rates), $28,500. Almost nobody factors that into the comparison; everyone should.

Building is the cheaper option only when your time has zero alternative use. The minute your hours could earn anything else, the math flips.

Hidden costs that don't show up in the listing price#

The line-item comparison above flatters both sides. The honest comparison includes the costs neither path advertises.

Buy path hidden costs: vendor lock-in (you're stuck with whatever language and architecture they chose), payment-processing limits (some scripts hardcode a single payment gateway you may not want), the cost of removing branding the vendor sneaks into emails or footers, the ongoing tax of merging vendor updates if you've made any custom changes, and the reputational risk of running software that hundreds of other resellers also run — your customers may have used a competitor running the same script.

Build path hidden costs: the months between "first commit" and "first paying customer" with zero revenue, the maintenance tax once you've shipped (security patches, library updates, the customer who finds an edge case at the worst possible moment), the support load (you're the only person who knows the codebase well enough to fix things), and the morale cost of working on infrastructure when you'd rather be working on features. New founders chronically underestimate maintenance — the rule of thumb in software is that maintenance equals 60–70% of total lifetime cost, per Glass's law on software economics.

The cost calculator#

Plug in your numbers. The widget below totals the all-in cost for each path over your chosen time horizon, including unpaid labour at your stated opportunity cost.

The license fee field auto-fills with the live Linked.Codes lifetime price (discount applied if there's an active campaign). The other defaults: $40/hour opportunity cost, 240 hours of build time (six months at ten hours a week), $60/month hosting and email. At those numbers, the buy column comes in roughly $9,000–$10,000 cheaper over twelve months — a gap that takes years to close even if you stay in the niche.

Push the rate to $0 (your time has no other use) and building wins. Push the build hours below 60 (you're forking something nearly working) and building wins. Stretch the horizon to 36 months and the gap narrows. The framework matters more than any single answer — but if your default is "I'll just build it", the spreadsheet usually disagrees.

The time you actually have#

Most people get this question wrong because they're answering "what would I do if I had unlimited time?" rather than "what makes sense given my actual life?" The honest version of the question:

• How many hours per week can you genuinely give this for the next six months — not the optimistic figure, the post-day-job-and-relationships figure?
• Do you have an income runway long enough to cover six months of zero revenue from this product?
• Is your day-job hourly rate (or your freelance rate) above $30/hour? If yes, the opportunity cost is real even if no money changes hands.
• Have you shipped a comparable production system before? If no, double every estimate.

If your answer is "ten hours a week", "yes I have runway", "$50/hour", and "yes I've shipped before", building is reasonable. If your answer is "five hours a week", "barely", "I make $25/hour", and "this would be my first", buy a license, ship in two weeks, and see if anyone pays you before you commit to nine months of work.

How to decide — a four-question checklist#

Skip the philosophy. Walk through these in order:

1. Can you find a license that does ≥80% of what you want? If no, you're building. If yes, continue.
2. Is the vendor still actively shipping updates this year? Check the changelog or commit history. If they've gone dark, the license has a short shelf life — building or finding a different vendor is safer.
3. Does the calculator above show a difference greater than $5,000 in favor of one path? If yes, take that path unless you have a strong non-cost reason to go the other way.
4. Do you plan to be in this niche for more than two years? If yes, building's lock-in advantage matters. If you're testing a thesis, buying lets you exit cleanly.

The decision falls out of the answers. People stall on this question because they're hoping for permission to do the more romantic option (build) when the math says rent. There's no shame in renting your way to first revenue — most early-stage SaaS founders we know launched on rented infrastructure and only rebuilt once they knew the niche worked.

Common scenarios#

You have a day job paying $80/hour and ten hours a week to spare. Buy. Your opportunity cost is too high to absorb six months of evenings on infrastructure work. The lifetime tier costs roughly half a day of your day-job rate.

You're between contracts with three months of runway and want to ship something. Buy, ship, market. The build path consumes your runway with no revenue. A two-week deploy on a license gets you to "is anyone paying" inside the runway you have.

You've already built five SaaS products and the niche is one you'll stay in for a decade. Build. Your build hours are faster than the calculator estimates because you've done it before, and the long horizon rewards owning the codebase outright.

You need a feature no license offers. The "buy" question is moot — you're building the differentiator regardless. Whether you build the rest from scratch or buy a base and bolt the differentiator on top is a smaller question. If the SaaS you're considering is specifically a QR generator, the QR-generator side-project scope breakdown walks the actual evening-hours under that label.

A separate consideration once you've picked a path: whether the license (or your own build) lets every customer ship links on their own domain. The recipient-facing trust math in branded short links, trust, and the click you lose applies to every reseller customer you'll ever have, and a license that locks tenants onto the platform vendor's host gives away most of the upside.

When neither wins#

Sometimes the right answer is neither. If your idea hasn't been validated — no waitlist, no preorders, no customer interviews — neither path makes sense yet, because both require a meaningful investment that pays off only against real demand. Validate first. A landing page, a manual no-code MVP, a stack of conversations with potential customers will tell you in two weeks whether the niche is real.

If validation comes back positive, you're in the buy-or-build comparison from a position of strength: you know who pays, what they pay for, and what trade-offs they'll tolerate. If validation comes back negative, you've saved six months of build effort or a five-figure license fee. The pre-decision is the most valuable one.

Linked.Codes is in this same lane: we sell the platform, you bring the domain and customers. If "neither buy nor build" sounds like the right answer because you want to focus on the customer side, that's the model — see owning your link infrastructure for the case for going independent without writing the auth and billing layer yourself.

What we did#

Linked.Codes was built, not bought — but only because the operator had shipped a few SaaS products before and had been in this niche for years. The build took six months of evenings, plus another two months of paying customers shaping the roadmap. Entering this niche cold today, the call would be: buy a license, ship in two weeks, use the first ninety days of revenue to figure out whether to stay. The 30% the calculator hands building over twelve months only pays off in years three and four, and most products don't survive long enough to collect.

So this article exists partly because of self-interest — Linked.Codes is one of the licenses on the buy column. One-time payment for the lifetime tier, you bring the domain and the customers, hosting starts free and adds modular per-month layers if you outgrow it. You skip the marketplace gamble (a vendor going dark, a script written for a different decade) and the six months of building auth, billing, multi-tenancy, and TLS automation yourself. The honest framing: if you're going to land on the buy column anyway, this is one of the cheapest, most current options in the niche. The current price (and any active discount) shows in the pricing page and in the calculator above. If lifetime pricing in this category is new to you, the lifetime URL shortener pricing math post covers the break-even and the survival risks worth pricing in before paying once.