The cloud was supposed to solve infrastructure forever. Pay for what you use, forget about hardware, let Amazon and Google handle the hard parts. For a while, that story held up. Then the invoices started arriving, and a lot of indie developers and small teams quietly started moving workloads back to VPS boxes and bare metal servers — not because the cloud got worse, but because they finally understood what they were actually buying.
The self-hosting vs cloud 2026 calculus is genuinely different from what it was in 2019. Managed services have proliferated to the point where almost anything can be outsourced. Simultaneously, VPS providers like Hetzner have made raw compute so cheap that running your own Postgres instance or analytics stack on dedicated hardware costs a fraction of managed equivalents. The decision is no longer ideological. It is economic and operational, and it deserves the same rigor you would apply to any other infrastructure choice.
This piece is for developers and small technical teams who already understand the basics and want a framework for making these calls without a lot of hand-waving. The numbers here are real. The maintenance estimates are from experience, not from vendor documentation.
Why Developers Are Pulling Workloads Back
The renewed interest in self-hosting is not a nostalgia movement. It is a response to a pattern that emerged over the past several years: managed cloud services are extremely convenient at the start, and extremely expensive at scale — where “scale” for an indie developer might mean a few thousand users, not millions.
For a well-funded startup sprinting toward product-market fit, paying the AWS premium is rational. For a bootstrapped team with predictable traffic and problems they already know how to solve, a 400–600% markup on managed services is harder to justify. There is also a counterintuitive point experienced operators arrive at: a single well-configured VPS running three or four services is often easier to reason about than a distributed cloud stack with five managed services, a dozen IAM roles, and billing that requires a dedicated dashboard to interpret.
Hetzner’s CAX series of Arm-based cloud servers — starting at around €4.51/month for 2 vCPUs and 4GB RAM — put this in sharp relief. For the price of a single managed Redis instance on a major cloud provider, you can have a capable server running your entire data layer.
The Real Cost Comparison
Abstract comparisons are not useful. Here is a concrete example: a typical indie SaaS stack for a product with 2,000–5,000 monthly active users, requiring a web application, a PostgreSQL database, a Redis cache, basic analytics, and a monitoring solution.
AWS (us-east-1, on-demand pricing)
- EC2 t3.medium (web app): ~$33/month
- RDS PostgreSQL db.t3.medium: ~$55/month
- ElastiCache Redis cache.t3.micro: ~$18/month
- CloudWatch basic monitoring: ~$10/month
- Data transfer (50GB outbound): ~$5/month
- Total: ~$121/month — before load balancers, backups, or any additional services
DigitalOcean (managed services)
- Basic Droplet 2vCPU/4GB (web app): $24/month
- Managed PostgreSQL (1GB RAM): $15/month
- Managed Redis (1GB): $15/month
- Basic monitoring (included)
- Total: ~$54/month
Hetzner CX32 (self-managed, everything on one box)
- CX32: 4 vCPUs, 8GB RAM, 80GB SSD: €10.90/month (~$12)
- Automated offsite backups (Hetzner snapshots or Borgmatic to object storage): ~$3/month
- Uptime monitoring (self-hosted Uptime Kuma): $0
- Total: ~$15/month
The $15 option runs Postgres, Redis, your application, and Uptime Kuma on a single server with 4 cores and 8GB of RAM. For most indie products at this user count, that hardware is not the bottleneck. The annual difference between AWS and the Hetzner option is roughly $1,270. Over three years, you could buy a dedicated bare metal server outright for that delta.
The counterargument is time. The AWS setup requires minimal operational involvement after initial configuration. The Hetzner setup requires you to manage Postgres updates, handle backups, monitor disk usage, and respond to the occasional service failure. That time has a real cost, and we will address it directly.
What Is Worth Self-Hosting
The services that make sense to self-host share a common profile: they are well-understood, have mature tooling, generate stable workloads, and carry high managed-service premiums relative to their operational complexity.
Databases (PostgreSQL, MySQL, SQLite)
Postgres is the canonical self-hosting candidate. It is stable, well-documented, and the operational requirements — regular vacuuming, WAL management, backup verification — are learnable in an afternoon. Running Postgres yourself on a CX32 or a Hetzner Dedicated AX41 costs a small fraction of RDS. The managed service makes sense if you genuinely cannot afford downtime during major version upgrades or if your team has no one capable of managing a database. For most indie teams, that is not the situation.
Analytics (Plausible, Umami, PostHog OSS)
Privacy-focused analytics platforms are among the highest-value self-hosting targets. Plausible Cloud runs at $9/month for up to 10,000 pageviews and scales from there. A self-hosted instance on a box you already own costs nothing marginal. You control the data — which matters for GDPR compliance and audience trust. PostHog’s open-source version is meaningfully more capable than the hosted free tier and runs comfortably on modest hardware once you tune the ClickHouse configuration.
Git Hosting (Gitea, Forgejo)
Gitea and its community fork Forgejo are lightweight, fast, and require almost no maintenance once deployed. For teams keeping source code off GitHub’s infrastructure — for compliance, cost, or independence — self-hosted git is an easy win. The entire stack runs in under 512MB of RAM and adds no meaningful load to a mid-range VPS.
Monitoring and Observability (Grafana + Prometheus, Uptime Kuma)
Grafana Cloud and Datadog carry significant monthly costs that scale with data volume. A self-hosted Prometheus + Grafana stack gives you equivalent visibility for the cost of the compute it runs on. Uptime Kuma takes about twenty minutes to deploy and requires almost no resources. The main trade-off is alert routing — PagerDuty handles on-call escalation better than anything you will build yourself, but for a small team, a Telegram or Slack webhook is entirely sufficient.
File Storage (MinIO, Garage)
S3-compatible object storage runs as a self-hosted service at a fraction of S3 pricing when your storage volumes justify it. MinIO is straightforward to operate and integrates with any S3 SDK. At $0.023/GB/month on S3 versus Hetzner’s €0.0119/GB/month on their Object Storage service, the difference is meaningful at hundreds of gigabytes. Self-hosting MinIO on your own hardware goes further still, especially for large media files or backups.
What Is Not Worth Self-Hosting
The services that belong in managed hands share a different profile: specialized compliance requirements, serious liability when they fail, network scale that individual servers cannot match, or regulatory complexity disproportionate to any savings.
Authentication and Identity
Auth is the wrong place to optimize for cost. A misconfigured session token, a broken password reset flow, or a PKCE implementation error does not just cause downtime — it creates a security incident. Services like Clerk, Auth0, and WorkOS absorb the complexity of OAuth 2.0, OIDC, MFA, passkeys, and enterprise SSO so that you do not have to. The time you save not debugging JWT edge cases pays for years of the subscription.
Payments
Stripe’s 2.9% + $0.30 per transaction is not a hosting cost — it is a compliance and liability cost. PCI DSS compliance for a self-managed payment flow is a significant undertaking, and the audit trail, fraud detection, and dispute handling infrastructure Stripe provides would cost far more to replicate. Do not self-host payments.
CDN and DDoS Mitigation
Cloudflare’s free tier covers CDN, DDoS mitigation, and basic WAF for most indie products. The network Cloudflare operates — with over 300 points of presence — cannot be approximated by a self-hosted Varnish instance or a few nginx caches. This is a case where the managed service is both better and cheaper than anything you could build. The only reason to move off Cloudflare is compliance requirements that prohibit third-party traffic inspection.
Transactional Email Delivery
Sending from your own IP is technically straightforward. Building sender reputation, managing bounces, maintaining DKIM and SPF records, and dealing with deliverability issues when your IP lands on a blocklist — that is a part-time job. Postmark, Resend, and Amazon SES at $0.10 per 1,000 emails are not expensive relative to the deliverability risk of getting it wrong. Self-host for receiving and storing mail if you want. For transactional sending, use a specialist provider.
DNS
Running your own authoritative DNS is a maintenance burden with essentially no upside for most teams. Cloudflare DNS and Route 53 at $0.50/hosted zone/month solve this reliably at a fraction of the failure cost — which is every service you operate going unreachable simultaneously.
The Maintenance Reality
Self-hosting has a time cost that is easy to undercount when you are excited about saving $80/month on managed Postgres. Here is an honest estimate for a small self-hosted stack (web app + database + Redis + monitoring) on a single VPS:
- Initial setup: 4–8 hours for a clean, documented deployment with backups and monitoring configured
- Routine maintenance (monthly): 1–2 hours — security patches, backup verification, disk and memory review
- Postgres major version upgrades (annually): 2–4 hours including testing and rollback verification
- Incident response (estimate 1–2 incidents/year): 2–6 hours per incident
- Annual total: roughly 20–35 hours
At a conservative $75/hour opportunity cost, that is $1,500–$2,600 per year in time. Against the $1,270 annual savings from the AWS comparison above, the math is close — and tips toward managed services if your time is constrained. The calculus shifts when you are already operating infrastructure for other reasons or when multiple services share the same box. A developer running four or five services on a single Hetzner server has a far better time-to-savings ratio than one maintaining dedicated infrastructure per service.
The other variable is risk tolerance. A managed Postgres instance from DigitalOcean has a clear SLA and a support team you can call when something goes wrong at 2 a.m. Your self-hosted Postgres instance has you, your runbooks, and whatever you can find on Stack Overflow at that hour.
The Hybrid Approach
The most pragmatic position is a deliberate hybrid: self-host where cost savings are large and operational complexity is manageable, use managed services where reliability, compliance, or specialized expertise matter more than the bill. A workable stack for a typical indie product:
- Self-hosted on Hetzner CX32: PostgreSQL, Redis, application runtime, Plausible analytics, Grafana + Prometheus, Gitea
- Managed services: Cloudflare (CDN, DNS, WAF), Clerk or Auth0 (authentication), Resend or Postmark (transactional email), Stripe (payments), Backblaze B2 or Hetzner Object Storage (offsite backups)
This configuration runs at roughly $30–$50/month total, with the managed services covering the high-risk surface areas and the self-hosted stack handling the predictable, well-understood workloads. It eliminates the most expensive managed service line items while retaining professional-grade solutions for auth, payments, and delivery.
The key discipline is not adding managed services out of convenience when a self-hosted option would serve equally well, and not self-hosting out of principle when the operational complexity is not justified by the savings.
A Decision Framework by Service Category
The following heuristics apply to the most common service categories an indie team encounters. They are starting points, not rules — your specific situation, team size, and risk tolerance all modify the answer.
Databases
Self-host if: your team has at least one person comfortable with Postgres operations, you have predictable traffic, and backup/restore procedures are documented and tested. Use managed if: you are pre-launch and cannot afford database downtime during a critical growth window, or the team has no operational database experience.
Analytics
Self-host if: you value data ownership, your pageview volumes would make hosted plans expensive, or GDPR compliance is a priority. Use managed if: you want event-level product analytics with minimal setup (Amplitude, Mixpanel) and the cost is below $50/month.
Email (transactional)
Always use managed delivery. The deliverability and compliance complexity is not proportionate to the savings for most teams below $500/month in email spend.
Authentication
Use managed below 10,000 MAU. The free and low-cost tiers of Clerk, Auth0, and similar services cover most indie products. Self-host Authentik or Keycloak only if you have a compliance requirement, enterprise SSO needs, or a large active user base that makes managed pricing prohibitive.
Object Storage
Self-host (MinIO or Garage) if: you store more than 500GB and already operate your own hardware. Use Hetzner Object Storage or Backblaze B2 if: you want S3 compatibility at a fraction of S3 pricing without managing storage infrastructure.
Monitoring and Uptime
Self-host for infrastructure metrics (Prometheus + Grafana). Use managed for uptime checks that need to originate from outside your network — Better Uptime and Freshping have useful free tiers. Alerting pipelines for larger teams benefit from a managed on-call product.
CI/CD
Use managed (GitHub Actions, GitLab CI) unless you have high build volume that makes per-minute pricing expensive, or compliance requirements that prevent sending code to external systems. Self-hosted runners on Hetzner are economical at scale but add meaningful maintenance overhead.
The Bottom Line
The self-hosting renaissance of 2024–2026 is not developers rejecting the cloud — it is developers getting better at reading the fine print. Managed services solve real problems and carry real costs. Self-hosted infrastructure creates real savings and real operational obligations. Neither side of that trade-off is free.
The developers who manage this well think about it systematically rather than defaulting to ideology. They know exactly what managed services cost, what replacing them would cost, and what their time is worth. They self-host the boring, stable parts of the stack and pay for expertise where mistakes are expensive.
Start with your cloud bills for the last three months and identify the five highest line items. For each one, ask: could I run this on a $15/month Hetzner box, and what would it actually cost in time? For most indie teams, two or three of those items will have a clear answer — and acting on them will cover the next year of infrastructure costs before the quarter ends.