# Self-host vs managed: the real cost comparison

> What self-hosting BuildBase really costs: a custom-priced license plus compute, a managed database, monitoring and patch time, line by line against one flat managed bill.

- Source: https://www.buildbase.app/blog/self-host-vs-managed-cost
- Section: Blog
- Author: Dharmendra Jagodana
- Published: 2026-08-29

## In short

Self-hosting BuildBase is custom-priced, and on top of that license you pay for compute, a managed database, monitoring and the hours to patch and run it. Priced in dollars, that ops time is the largest line, and it pushes the self-hosted total past the managed plan before the license is counted.

BuildBase ships a self-hosted option: your own Docker containers, your own
database, the same 20 modules, on a license priced for your setup rather
than a public plan. The pitch writes itself - your infrastructure, your
control. Pricing the infrastructure out looks just as easy: one small VPS
running the whole quick-start compose file comes in under $30 a month, not far
off the Launch plan's $19.

That number is not the bill. It never is - the same blind spot shows up
[pricing a database per tenant](/blog/database-per-tenant-cost) and
[pricing an assembled vendor stack](/blog/auth-billing-stack-cost): the
sticker price is real, and it is the smallest part of the real cost. A
single box with no managed backups and no redundancy is also not what
anyone would actually run once paying customers depend on it - so that is
not the setup this post prices out.

## The assumptions

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

- **The self-hosted license is left out of every total.** Self-hosting is
  custom-priced per setup, so there is no public figure to put in the table.
  Every number below is before it, which makes this comparison generous to
  self-hosting, not harsh on it.
- **A workload sized like the Launch plan** - up to 25,000 monthly active
  users, the tier most teams actually evaluating this trade-off sit at.
- **A production-grade setup**, not the single-VPS quick start. Two `app`
  replicas behind an nginx load balancer, which is exactly what BuildBase's
  own `deploy/docker-compose.prod.yml` defaults to, plus an externally
  managed database - that template ships no database service at all, unlike
  the quick-start compose, so you bring your own.
- **A fully loaded US backend engineer costs roughly $70 an hour.** Public
  salary data puts the range closer to $58-$85 depending on seniority and
  market; $70 is a stated midpoint, not a sourced vendor figure. Halve or
  raise it and the shape of the argument does not change.
- **Three hours a week of patch and on-call time** - OS and dependency
  patches, a database or Redis version bump every so often, checking a
  backup actually restores, responding to the occasional alert. This is a
  stated assumption, not a benchmark, and it is the number most worth
  arguing with.
- Compute and database prices below are commodity 2026 rates for VMs and a
  small managed database tier, gathered from public pricing summaries rather
  than a single invoice - directional, not a quote you can hold a vendor to.

## The arithmetic

| Line item              | Monthly cost | Where it comes from                                                                                                             |
| ---------------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------- |
| Compute, 2 nodes       | ~$48         | Two small cloud VMs at roughly $24 each, 2 vCPU / 4 GB - sized above the platform's stated 2 GB minimum for production headroom |
| Managed database       | ~$57         | A small dedicated managed database tier                                                                                         |
| Redis                  | $0           | Runs in your own container - the one line self-hosting actually saves                                                           |
| Monitoring             | $0           | Covered by a free ingest tier at this scale                                                                                     |
| Patch and on-call time | ~$910        | 3 hrs/week, ~13 hrs/month, at $70/hr                                                                                            |
| **Total**              | **~$1,015**  |                                                                                                                                 |

Compute and the managed database together come to roughly **$105 a month**,
before the license - already past Launch's $19, Grow's $49 and Scale's $99 too, before anyone opens a
terminal to patch anything. Add the hours it actually takes to run that
infrastructure and the total lands over fifty times Launch's plan price
for the equivalent workload.

> **Key takeaway:** The infrastructure self-hosting replaces is the cheap part. The hours to
> patch, monitor and be on call for it are the expensive part, and they are the
> part every self-hosting pitch leaves off the calculator.

## What moves the total

Sensitivity matters more than the headline. Halve the assumed ops time to
1.5 hours a week and the total is still roughly **$560 a month** - more than
twenty-nine times Launch's plan price, and still more than five times Scale's
$99. Cut the hourly rate to $35 instead, leave the hours alone, and you
land at about **$560** again. Same number, different lever. That tells you
this figure is dominated by hours, not by rate - halving either one cuts the
total by the same amount, because the patch-and-on-call line is the only one
that scales with attention instead of a vendor's price sheet.

The one line that moves the other direction is Redis. Running it in your own
container instead of paying for a managed tier is a real saving against what
a managed Redis tier would otherwise cost. It isn't free of risk, though -
BuildBase backs sessions and BullMQ workflow queues with Redis, with
append-only persistence enabled in the self-hosted compose, so losing that
container without a working backup costs you active sessions and queued
workflow runs, not nothing.

## Where this math stops applying

**You already carry the ops capacity.** If patching and on-call for this
stack rides along with patching and on-call you're already doing elsewhere -
same engineer, same rotation, no new hire - the marginal hours are close to
zero. The calculus flips. This post prices the hours as new; for a team that
already staffs them, they are not.

**Data residency or a contract requires it.** When a customer or a regulator
requires the database to sit somewhere specific, self-hosting is not a cost
decision being weighed against a managed plan. It is a term of the deal, and
the number above is what that term costs to deliver.

**The workload outgrows the flat plan anyway.** Past Scale's included
500,000 MAU, BuildBase's own pricing moves to a custom Enterprise
conversation rather than a fixed $99. At that size the comparison in this
post - a fixed plan price against a self-hosted total - is not the one that
applies. The real question becomes what a custom managed contract costs
against the same infrastructure at that scale - and that math needs its own
post.

## Where BuildBase sits in this

Self-hosting BuildBase does not trade away modules - every module on the
[managed plans](/pricing) ships in the [self-hosted](/self-hosted) image too.
What you are actually buying with the monthly plan price is someone else
carrying the three hours a week this post prices out, plus the on-call
rotation behind it. Whether that is worth roughly $910 a month depends
entirely on whether your team's ops hours are already spoken for - which is
an honest question this post can price but cannot answer for you.

It's also a different question from [whether to build the modules
yourself](/blog/buy-vs-build-saas-infrastructure) in the first place.
Self-hosting still means running BuildBase's auth and metering, not writing
your own - the ops-hours math above and the build-hours math there answer two
different questions that only look like one.
