# Buy vs build for SaaS infrastructure

> Buy-vs-build calculators price one module at a time. The real decision compounds across every module a SaaS needs, and the tipping point is not where most posts put it.

- Source: https://www.buildbase.app/blog/buy-vs-build-saas-infrastructure
- Section: Blog
- Author: Dharmendra Jagodana
- Published: 2026-09-03
- Updated: 2026-09-22

## In short

Building auth and usage metering yourself runs about $162,000 in year one for one engineer, using this site's own published figures for each. A managed platform covering both is $190 a year. That gap comes from needing both modules at once, which single-module calculators never price.

Every buy-vs-build framework asks the question one module at a time. Should
you build auth, or buy it? Should you build billing, or buy it? Priced
separately, both questions come out close enough to argue about, which is
exactly why the posts answering them read like a coin flip.

Priced together, for one team building both in the same year, they stop being
close. Here is the arithmetic, using this site's own published, line-item
figures for two modules rather than a new estimate invented for this post.

## The question

What does it cost one team to build and maintain the infrastructure a normal
B2B SaaS needs in its first year, against paying for a platform that already
has it?

## The assumptions

Nothing new here. These are the same inputs [the auth-cost
post](/blog/cost-of-building-auth-yourself) and [the metering-cost
post](/blog/cost-of-building-usage-metering-yourself) already derived and
showed their work on - reused, not re-invented, so the totals below stay
traceable to arithmetic you can go re-check.

- **One senior engineer**, loaded at **$150 an hour**, building both modules
  in sequence rather than two engineers building them in parallel.
- **Auth scope**: email/password signup, sessions, password reset, one OAuth
  provider. No SSO, no MFA.
- **Metering scope**: idempotent event ingestion with correction and backfill
  tooling, not a single incrementing counter.
- **Maintenance held at 20% of build cost every year**, the same benchmark
  both source posts use, for patching, provider API changes and the
  correction bugs each domain produces on its own schedule.
- **Mid-scenario build times from each source post**: 4.5 weeks for auth,
  4.5 months for metering.
- Buy-side price is BuildBase's own Launch plan, verified against the
  platform constants on 31 October 2026.

## The arithmetic

| Module         | DIY build (mid) | DIY maintenance, yr 1 | Year-one total |
| -------------- | --------------- | --------------------- | -------------- |
| Auth           | $27,000         | $5,400                | $32,400        |
| Usage metering | $108,000        | $21,600               | $129,600       |
| **Combined**   | **$135,000**    | **$27,000**           | **$162,000**   |

$162,000 to build and maintain two modules, for one year, with one engineer.
BuildBase's Launch plan, which covers auth and metering alongside billing and
workspaces rather than either alone, is $190 a year paid annually.

That is not a fair one-line comparison and it is not meant to be read as one.
$190 buys more scope than the $162,000 does - it also buys billing and
workspaces, which the DIY total above does not include at all. Even granting
that gap generously, doubling or tripling the managed price to account for it
does not get anywhere near six figures.

## The total, and what actually moves it

The $162,000 headline is not the interesting number. The interesting number
is that it is not $32,400 plus $129,600 read as two separate, comparable
decisions - it is one number, because one team has to carry both maintenance
lines going forward, every year, on top of whatever they build next.

That's the part single-module calculators miss structurally, not by
oversight. A post that prices auth alone is honest about auth and silent
about the four or five other things the same SaaS still needs - billing,
workspaces, notifications, feature flags. Each one adds a full year-one build
plus a recurring maintenance tax, and those maintenance hours don't average
out across modules. They stack, on the same one or two engineers, who also
have a product to ship.

> **Key takeaway:** Auth alone or metering alone can honestly go either way. Needing both at once,
> on the same team, is what turns a marginal call into a $162,000 question - and
> every module past the second one moves the answer further in the same
> direction.

That's also a different failure mode than the one [the vendor-stack
post](/blog/auth-billing-stack-cost) covers. Buying four best-of-breed
vendors instead of building avoids the $162,000, but it swaps the build-hours
tax for an integration tax - four webhook formats, four auth models, four
places a number can drift - that a subscription total never shows either.
Building, assembling, and buying one platform are three different trades,
not two.

## Where this math stops applying

**You only need one module, not several.** Building auth alone at
$21,600-$43,200 is a defensible call for plenty of teams, [as the source post
argues](/blog/cost-of-building-auth-yourself). The case for buying gets
stronger with each module added to the same build, not because any one of
them got more expensive, but because the team carrying the maintenance did
not grow to match.

**Infrastructure is your actual product.** A billing or auth company is
pricing this in reverse - none of it is overhead, it's the thing being sold.

**Your engineer's rate sits well below $150 an hour.** The gap compresses at
a junior or offshore rate, though not by enough to flip a two-module build:
even at $50 an hour, $162,000 becomes $54,000, still two orders of magnitude
past $190.

**You already have idle ops capacity.** [Self-hosting the same
modules](/blog/self-host-vs-managed-cost) trades the license line for
compute, a managed database and patch time, which is a different axis from
this post entirely - it's managed-versus-self-hosted, not build-versus-buy,
since self-hosting still means running BuildBase's modules rather than
writing your own.

**You're past roughly 1,000 tenants.** At real scale [the tenancy model
itself becomes the binding cost](/blog/database-per-tenant-cost), and the
constraint shifts from engineering hours to a connection-pool ceiling that no
build-cost table on this page prices in.

## Where BuildBase sits in this

We didn't write this post to make the arithmetic land somewhere convenient.
PlugNode, AgentCenter and Imejis - three of the six products we run
ourselves - use auth and OAuth, team workspaces, Stripe billing and
usage-based credit metering, the exact module set this post prices out
separately, on one platform instance each rather than a separately built and
maintained stack. That's less a claim about BuildBase and more a description
of what not re-deriving this math five times actually looks like day to day:
infrastructure work like this is estimated to eat 60-70% of engineering time
on a typical SaaS team, and every module you build instead of buy is a slice
of that percentage with your name on it, every year, not just at launch.
