Self-hosting conversion tools feels like it should be the obvious choice — FFmpeg is free, LibreOffice is free, a VPS is $20/month. Why pay $99–$499/month for a managed API?
The answer: the tools are free, but the infrastructure, maintenance, uptime, and on-call burden are not. This guide does the full math — infrastructure costs, setup time, maintenance hours, and the volume at which self-hosting actually wins. All dollar estimates use April 2026 pricing for typical cloud infrastructure and engineering rates.
TL;DR — when does self-hosting win?
Quick break-even analysis at common volume tiers:
| Volume/month | Self-hosted TCO (est.) | CTF API cost | Verdict |
|---|---|---|---|
| 10,000 conversions | $170–$650 (infra + eng time) | $29 (Hobby) | API wins by far |
| 50,000 conversions | $170–$650 | $99 (Startup) | API still wins |
| 200,000 conversions | $170–$650 | ~$1,050 (Scale + overage) | Self-hosting starts winning |
| 500,000 conversions | $200–$700 | $499 (Scale) | Break-even or self-hosting wins |
| 1M+ conversions | $300–$900 (scaled infra) | $1,999 (Growth) | Self-hosting wins clearly |
Self-hosted TCO = VPS cost + (maintenance hours × engineering rate). At $75/hour for 2 hours/month minimum, you're paying $150/month in hidden cost before touching infrastructure.
What self-hosted FFmpeg/LibreOffice actually costs
Infrastructure (April 2026 Hetzner/DigitalOcean/Linode estimates):
| VPS tier | CPU | RAM | Est. capacity | Monthly cost |
|---|---|---|---|---|
| Entry (Hetzner CX22) | 2 vCPU | 4 GB | ~20K–50K simple conversions | ~$5–$8 |
| Standard (Hetzner CX32) | 4 vCPU | 8 GB | ~50K–150K simple conversions | ~$12–$18 |
| Production (Hetzner CX42) | 8 vCPU | 16 GB | ~150K–500K simple conversions | ~$25–$40 |
| High-volume (dedicated) | 16+ vCPU | 32 GB+ | 500K+ conversions | $80–$200+ |
Capacity estimates assume a mix of image conversions (~5s each) and document conversions (~30s each). Video transcodes are CPU-intensive — a 4 vCPU server handles roughly 20–40 concurrent short video transcodes before queuing. LibreOffice headless is single-instance — only one document converts at a time unless you run multiple instances with a load balancer.
Setup time (one-time):
- VPS provisioning + OS configuration: 1 hour
- FFmpeg install + verify codecs: 1 hour
- LibreOffice headless + xvfb setup: 2 hours
- Calibre + 7-Zip + Ghostscript: 1 hour
- Express/Node.js API wrapper: 2–4 hours
- Systemd service + monitoring: 1 hour
- Testing and debugging: 2–4 hours
- Total: 10–14 hours
At $75/hour senior engineer rate: $750–$1,050 one-time setup cost.
The hidden maintenance burden
Monthly maintenance work (realistic estimate for a production server):
- Security patches (FFmpeg CVEs are common): 0.5–1 hour/month
- Investigating stuck or zombie FFmpeg processes: 0.5 hour/month average
- LibreOffice headless crashes and restarts: 0.5 hour/month average
- Disk cleanup (temp files from failed conversions): 0.25 hour/month
- Monitoring and alerts review: 0.25 hour/month
- Total: 2–3 hours/month baseline
At $75/hour: $150–$225/month in hidden engineering cost. This is the number most self-hosting TCO analyses omit entirely.
On-call incidents (sporadic but real):
- Server goes down on a Saturday night: 1–3 hours to diagnose and restore
- FFmpeg version update breaks a codec: 2–4 hours to roll back or fix
- LibreOffice OOM kills during batch: 1–2 hours to tune memory limits
A conservative estimate of 1 incident per month × 2 hours = $150/month in additional hidden cost. More aggressively managed servers with good monitoring can reduce this.
Other costs often missed:
- Backups: $2–$5/month for VPS snapshots
- Monitoring tools: $0 (Netdata/Prometheus) to $20/month (Datadog free tier)
- CDN/bandwidth if your server serves large output files directly: $5–$20/month
What managed APIs provide that self-hosting doesn't
1. Zero setup time. ChangeThisFile API: get a key, make one POST request. CloudConvert: create an account, read the docs, integrate the async client. Neither requires a VPS, a systemd service, or debugging LibreOffice headless display issues.
2. Automatic scaling. A managed API handles traffic spikes without pre-provisioning. Your product launches to 10,000 users in one day — the API scales. Self-hosted LibreOffice doesn't scale horizontally without significant engineering effort (load balancing, job queuing, horizontal pod autoscaling).
3. No CVE management. FFmpeg, LibreOffice, and Calibre have histories of high-severity CVEs triggered by malicious files. Managing updates, testing regressions, and maintaining a patching schedule is real work. Managed APIs absorb this responsibility.
4. Uptime SLA. Managed APIs typically offer 99.9%+ uptime SLAs with support. Self-hosted uptime is whatever you make it — if the server goes down at 2am and conversions are part of your critical path, you're the on-call engineer.
5. Format breadth without the complexity. Supporting 10+ conversion tools on one server (FFmpeg, LibreOffice, Calibre, 7-Zip, Ghostscript, Poppler, Sharp, FontTools) creates dependency hell. Different tools conflict on shared libraries, and each has separate version management needs.
When self-hosting genuinely wins
Self-hosting makes financial sense when:
- Volume exceeds 500K conversions/month — at this scale, a $40/month VPS handles what would cost $499–$1,999/month from a managed API
- You already have dedicated devops capacity — a team with a platform engineer who manages servers anyway absorbs the maintenance cost into existing work
- You need custom FFmpeg flags or codecs — managed APIs don't let you pass arbitrary FFmpeg arguments. If you need NVENC hardware encoding, specific codec libraries, or custom presets, self-hosting is necessary
- Your files must never leave your infrastructure — for healthcare (HIPAA), legal, or classified data where files cannot be transmitted to third-party services, self-hosting is a compliance requirement, not just a cost choice
- You already use Kubernetes — teams running containerized infrastructure can add an FFmpeg + LibreOffice container to their existing cluster at near-zero additional operational cost
When managed APIs win (most teams, most of the time)
Stick with a managed API when:
- Monthly volume is under 500K conversions
- Your team is small (under 10 engineers) and server maintenance isn't a core competency
- You need multiple format types — maintaining FFmpeg + LibreOffice + Calibre + 7-Zip on one server is fragile
- Conversion is not your core product — it's a supporting feature. Operational risk on a non-core component isn't worth the savings
- You don't have existing devops infrastructure to absorb the maintenance
Complete TCO comparison over 12 months
| Option | Setup cost (one-time) | Monthly infra | Monthly eng | Annual TCO (100K/mo) |
|---|---|---|---|---|
| Self-hosted (VPS only) | $750–$1,050 | $25–$40 | $150–$300 | $3,000–$5,310 |
| ChangeThisFile Scale ($499) | $0 | $0 | $0 | $5,988 |
| ChangeThisFile Startup ($99) | $0 | $0 | $0 | $1,188 (at 50K/mo) |
| CloudConvert PAYG (30s avg) | $0 | $0 | $0 | $5,760 (at 100K/mo) |
At 100K/mo: self-hosted is $3K–$5K/year vs ChangeThisFile Scale at $6K/year. Converges. At 50K/mo: ChangeThisFile Startup at $1,188/year vs self-hosted at $2.5K–$4.5K/year — API wins easily.
Self-hosting FFmpeg and LibreOffice is a legitimate cost optimization at high volume with existing devops capacity. Below 200K conversions/month without a dedicated platform engineer, managed APIs win on total cost of ownership. ChangeThisFile's free tier is a good starting point: 1,000 conversions/month with no card, no server to manage, and a synchronous API that takes 10 minutes to integrate. Scale to paid when you know your actual volume.