Is self-hosting actually cheaper? Count the operator, the outage, and the exit.
The common argument is simple: replace a $15/user SaaS with an open-source tool on a $20 VPS and save thousands. The missing term in that arithmetic is the human operator who has to keep it running.
You leave with A 3-year TCO ledger comparing SaaS vs self-hosted across infrastructure, maintenance labor, upgrade risk, and exit cost, plus a downloadable calculation worksheet
No email required. Editable CSV with 10-seat and 50-seat comparison models and explicit hourly rate assumptions.
The short answer
- Under 25 seats: Managed SaaS is almost always cheaper in total cost of ownership. The developer or administrator labor required to patch, monitor, and back up a self-hosted stack outstrips SaaS subscription savings.
- Over 50–100 seats: Self-hosting becomes mathematically favorable if the application is stable, because operator hours remain roughly constant while per-seat SaaS fees scale linearly.
- The deciding variable: It is never the $20 VPS. It is whether your team has a named operator whose time is accounted for at real internal hourly rates ($75–$120/hr), or whether that maintenance is treated as free nights-and-weekends labor.
Evidence level: decision kit and cost model based on published vendor pricing and sysadmin operational logs. Not a benchmark of software performance.
The five costs omitted from the VPS comparison
Blog posts claiming “we saved $12,000 by self-hosting” usually compare sticker subscription fees against raw server hosting invoices. Here is the full ledger required to make a fair comparison:
| Cost Category | Managed SaaS | Self-Hosted Open Source | Operating Reality |
|---|---|---|---|
| Infrastructure | Included in subscription ($0 direct) | $25–$80/mo (VPS compute, block storage, off-site snapshots, transactional email) | Compute is rarely more than 10% of the true cost. |
| Initial Setup | 1–3 hours (team invite, SSO config) | 6–16 hours (Docker/K8s provisioning, reverse proxy, TLS, DNS, volume backups) | Initial deployment absorbs 1–2 working days of developer or sysadmin time. |
| Monthly Routine Maintenance | 0 hours (handled by vendor) | 2–4 hours/mo (OS security patches, container updates, disk monitoring, log rotation) | At $85/hr fully loaded engineering rate, this is $2,040–$4,080/year in labor. |
| Major Version Upgrades | 0 hours (continuous delivery) | 6–12 hours/year (schema migrations, breaking changes, staging tests, rollbacks) | Skipping upgrades creates technical debt and unpatched vulnerabilities. |
| Disaster Recovery Testing | Vendor SLA contract | 4 hours/year (proving a restore from cold snapshots without data loss) | An untested backup is not a recovery plan. |
| Exit & Migration | Standard JSON/CSV export API | Direct database dump or custom ETL script | Raw SQL dumps often require manual reconstruction in the destination tool. |
A worked 25-user scenario: Slack Pro vs. Self-Hosted Mattermost
Let's run the numbers on a real team of 25 people evaluating team chat over three years, using our lifecycle cost estimator:
In this scenario, self-hosting costs $3,180 more over three years because the 3 to 4 hours of monthly operator labor exceeds the SaaS subscription fee. Self-hosting only crosses the break-even point when the team grows to approximately 45 seats.
The Break-Even Formula
Before deciding whether to self-host, solve this inequality using your team's real numbers:
If your internal engineering cost is $85/hour and self-hosting requires 4 hours a month plus a weekend upgrade drill, your minimum operational overhead is $4,760 per year before paying a single dollar for servers.
When self-hosting makes complete business sense
Self-hosting is not a mistake; it is an architectural trade-off. It is the right decision when:
- Regulatory or data residency boundaries: Medical records, classified defense contracts, or sovereign data storage requirements where third-party cloud hosting is legally barred.
- High seat density with low maintenance: A 200-person company saving $30,000+ per year on SaaS licenses while dedicating 10% of a full-time DevOps engineer to maintenance.
- Single-binary, zero-maintenance tools: Software built with embedded SQLite and zero external runtime dependencies (e.g. Vaultwarden or PocketBase), where updates are as simple as replacing a single Docker image.
- Core capability ownership: When the software is central to your proprietary product architecture and you cannot tolerate upstream pricing shocks or platform deprecation.
Check your own stack
Test your exact seat count, licensing terms, internal engineering cost, and planned exit horizon with our free in-browser calculators: