# The cost of building auth yourself

> The real line-item cost of building auth in-house at small-SaaS scale, in hours and dollars, not the enterprise figures everyone else quotes.

- Source: https://www.buildbase.app/blog/cost-of-building-auth-yourself
- Section: Blog
- Author: Dharmendra Jagodana
- Published: 2026-08-27
- Updated: 2026-09-22

## In short

Building basic auth yourself (signup, login, sessions, password reset, one OAuth provider) runs 120-240 engineer-hours at $150 an hour, plus 15-25% of that every year in maintenance. At small-SaaS scale that is $21,600-$43,200 in year one, against $190 a year on a managed plan covering billing and workspaces too.

Search "cost of building auth" and you get two kinds of numbers. A vendor's
$300,000-to-$700,000 horror story, or an indie hacker's "I built it in a
weekend for free." Neither is the number you actually need.

The first prices a full passkey, MFA and fraud-detection stack sized for an
enterprise buyer. The second is one data point with no maintenance math
attached. What's missing from both is the arithmetic a two-person SaaS can
actually check against its own hours: what does a basic login flow cost to
build, and then to keep alive, in year one?

## The assumptions

Every input here is stated so you can swap in your own and recompute.

- **One senior engineer, not a team**, building it from scratch.
- **A loaded rate of $150 an hour.** ZipRecruiter, Indeed and Glassdoor put a
  senior US engineer's 2026 salary at roughly $143,000-$210,000; loaded
  cost - benefits, overhead, taxes - typically runs 30-70% above base, which
  is where the commonly cited $95-$180-an-hour range comes from. We're using a
  round $150, toward the middle. Halve it for a junior or offshore rate and
  the shape of the argument does not change, just the size.
- **Scope: email/password signup, session handling, a password reset flow
  and one OAuth provider** - Sign in with Google, say. No SSO, no MFA, no
  fraud detection. [The enterprise-scale figures you'll see
  elsewhere](/compare/auth0-vs-buildbase) are priced for those, not this.
- **Build time: 3-6 weeks per engineer.** That's our own published estimate
  for building auth from scratch, and it covers a broader scope than the one
  above - so treat it as an upper bound on this narrower build, not a precise
  fit. We'll show the low, middle and high end rather than pretend it's one
  number.
- **Maintenance: 20% of the original build cost every year after.**
  Cost-benchmarking write-ups on software maintenance put ongoing upkeep at
  15-25% of build cost annually - patching, dependency bumps, provider API
  changes - and we're using the middle of that too.

## The arithmetic

| Build time      | Hours | Build cost at $150/hr | Maintenance at 20%/yr | Year-one total |
| --------------- | ----- | --------------------- | --------------------- | -------------- |
| 3 weeks (low)   | 120   | $18,000               | $3,600                | $21,600        |
| 4.5 weeks (mid) | 180   | $27,000               | $5,400                | $32,400        |
| 6 weeks (high)  | 240   | $36,000               | $7,200                | $43,200        |

Maintenance is the row people forget to run. It doesn't show up on the day
you ship, so it's easy to price the build and stop there. It arrives instead
as a Tuesday when Google rotates an OAuth scope, or a password-reset email
starts landing in spam, or a dependency bump breaks session handling three
minutes before a demo.

## The total, and what moves it

The number that matters isn't the $32,400 in the middle row. It's that
the maintenance line repeats every year while the build cost doesn't. Cut
the maintenance rate in half, to 10%, and you're still paying $1,800-$3,600
a year, forever, just to keep a login screen working. That recurring bill is
the part the $300K horror stories and the weekend-build tweets both leave
out.

Set that against what the same year costs on a managed plan: BuildBase's
Launch tier is $19 a month, $190 a year if you pay annually, $228 if you pay
monthly, and the Free plan covers the same basic auth at $0 up to 10,000
monthly active users. Either way, it's a rounding error next to
$21,600-$43,200 - though it's a fair point that $190 also buys billing,
workspaces and RBAC alongside
auth, not auth alone. The comparison isn't "same scope, different price." It's
"what you'd actually pay to make this math moot."

> **Key takeaway:** A basic signup, login, session and one OAuth button costs $21,600 to $43,200
> for one engineer to build and maintain in year one. The same scope is $190 a
> year on a managed plan, and the gap is almost entirely the maintenance line
> nobody prices up front.

## Where this math stops applying

The arithmetic above doesn't decide everything.

**Auth is your actual product.** If you're building an identity or auth
company, none of this is overhead - it's the thing you sell, and the
calculation runs backward. You're not saving engineering time; you're
spending it on your moat.

**A customer needs more than a login button.** Once a deal requires
[single sign-on](/compare/workos-vs-buildbase), dedicated compliance work or
anything past this post's scope, you've left the basic build behind, and the
much bigger figures circulating elsewhere start to apply. This post is
deliberately about the smaller build most small SaaS teams actually need
first.

**Your engineer's rate is far from $150 an hour.** Junior-market or offshore
rates a third of that still don't flip the outcome - the mid-scope build at
$50 an hour is still $10,800 in year one, not $190 - but they do compress the
gap enough that the decision gets closer for a team that's genuinely
rate-constrained rather than time-constrained.

## Where BuildBase sits in this

We didn't do this math once and stop. BuildBase's own auth module runs
unmodified across six products we operate ourselves - PlugNode, AgentCenter
and Imejis among them - which is what building it once instead of six
times actually looks like. Auth is also just [the first bill in a bigger
pattern](/blog/auth-billing-stack-cost): infrastructure work like this is
estimated to eat 60-70% of engineering time on a typical SaaS team, and this
post covers one line item inside that, not the whole thing.
