Upsun Bills You Four Times for One App: What a Typical API + Postgres + Redis Stack Really Costs vs. a €4 Hetzner Box

Nobody picks Upsun because a single container is expensive. A few dollars a month for an always-on app with Git-driven deploys, branch previews, and managed patching is a bargain. Teams feel the bill later, when the invoice arrives with four independent meters running at once — a per-project fee, per-hour compute with different rates for apps versus services, per-GB storage and backups, and a per-user license — and every preview environment clones most of it.

So let us do the thing PaaS comparisons usually skip: price one concrete, boring, typical stack on both sides, line by line, at September 2026 rate cards. Here is the answer up front; every receipt follows below.

Four disclosures ride along with that table, because a multiplier without them is marketing. First, this is a list-price recompute from public pricing pages, not a scanned invoice — Upsun's pricing page plus third-party rate-card records, normalized at EUR→USD ~1.08, excluding VAT. Every rate below is cited so you can redo it. Second, the after side is a single node with no HA, running the API, Postgres, and Redis co-located, versus Upsun's managed, patched, multi-AZ-capable substrate — the "what the premium buys" section prices what closing that gap costs.

Third, ops and on-call time are excluded from both sides, which flatters Hetzner more than Upsun (Upsun's ops cost is bundled into its prices; Hetzner's is your evenings). Fourth, this stack's traffic fits inside both vendors' included bandwidth, so egress is $0 on both sides — the tax here is collected in compute, environments, and seats, not bytes.

The four dimensions, in plain English​

Upsun is Platform.sh's resource-based successor: no named plans, just meters. The hosting-provider record puts it cleanly — resources provisioned per project and billed by the hour, metered per second, on top of a flat per-project fee and a per-user license, with a no-card trial. An April 2026 third-party teardown structures the same bill into the four dimensions this post recomputes. Here is each one.

Dimension 1: the project fee. Roughly €9 per project per month covers orchestration, metrics, and build minutes — you pay it before a single request arrives. It is small and it is also unavoidable: ten micro-projects pay it ten times.

Dimension 2: compute, metered per hour — with apps and services priced differently. CPU and memory are billed per hour (per second granularity) for every running container, and service-tier resources (databases, caches) cost more per hour than application resources at the same size. Shared versus guaranteed CPU widens the band further. Upsun's own materials frame a basic production app around $4/month and a more complex setup at $30–40/month for compute alone — before the database, the cache, storage, backups, seats, and extra environments join in.

Dimension 3: storage and backups, per GB per environment. Disk is about €0.10 per GB, billed per environment — and backups are billed separately per backup snapshot. Twenty GB across three environments is not one 20 GB line; it is three of them, plus the backup copies.

Dimension 4: users and environments. Roughly €10 per user license per month, plus the environment multiplier: every running preview environment meters its own compute, storage, and backups. Branch previews are Upsun's best feature and its quietest cost lever — each one is a small copy of the production bill.

The February 2026 Back4App market snapshot corroborates the shape from the outside: it lists Upsun from €9/month with Git-driven deploys and enterprise compliance (SOC 2 Type 2, PCI DSS L1, ISO 27001, HIPAA), against Render from $7 and Railway from $5 with fixed or simpler meters. The entry price is honest. The all-in price is a sum of four meters, and this post adds them up.

The Upsun bill, line by line: ~$75–95/mo​

The reference stack is the smallest thing a real SaaS actually runs: a Node.js or Python API, a managed Postgres, and a Redis for sessions and rate limits — production plus two standing preview environments (staging plus one branch preview), three team members, 20 GB of disk, daily backups retained for a week.

Two rows deserve commentary. First, the service-tier premium is the line most estimates miss: the database and the cache cost more per CPU-hour than the API at identical sizes, and they run 730 hours a month each whether traffic arrives or not. Upsun's own "$30–40 for complex setups" figure covers compute for one environment's apps — the services, the second and third environments, the seats, and the backups sit on top of it, which is how a "$9 starting price" becomes a $80 invoice. The third-party teardown's rule of thumb agrees: even a small app lands at $50–100+/month all-in.

Second, the preview multiplier is a feature tax, not a bug: each branch environment that stays warm meters compute per hour plus its own disk and backups. Two small previews at roughly a quarter-production each add $10–20. Leave five feature branches warm over a busy sprint and previews alone can exceed the production compute line — exactly the behavior developers report when they say estimating an Upsun bill feels like forecasting the weather.

Sensitivity: where the bill actually moves​

• Add a third preview environment: +$5–10/mo. Five warm branches: +$25–50/mo — the meter scales with team habits, not traffic.
• Double the API to 2 vCPU / 4 GB: +$15–20/mo on the app line alone; double Postgres too and the services premium doubles with it.
• Grow disk from 20 GB to 100 GB across 3 envs: storage goes from ~€2 to ~€10/mo, plus larger backup snapshots — the quietest line becomes a visible one.
• Grow the team from 3 to 6: +~€30/mo in licenses before anyone deploys anything.

The pattern: nothing here is individually outrageous, and everything scales on an axis — environments, services, seats, gigabytes — that grows with a healthy team rather than with revenue.

The Hetzner bill, line by line: ~$4–5/mo​

The identical containers — same API, same Postgres, same Redis, co-located — fit on a single Hetzner Cloud CX22 (2 shared vCPU, 4 GB RAM, 40 GB NVMe) under a Cluster-API-managed single-node setup:

The consolidation assumption, stated plainly so you can reject it: a lightly-loaded API plus a few-GB Postgres and a small Redis fit in 2 vCPU and 4 GB with headroom — the standard single-box shape every migration writeup converges on, and 2026 catalog comparisons (Hetzner vs OVHcloud vs DigitalOcean) still list the CX22 at €3.79/month with 20 TB included, against DigitalOcean's $4 with 4 TB. The contention limit is equally plain: one noisy neighbor — a runaway worker, a Postgres vacuum storm, a traffic spike — and all three tiers degrade together, with no second node to fail over to.

If that sentence made you flinch, price the separated alternative: Postgres and Redis on a second CX22 costs ~€8/mo total (~$9), both nodes still flat, previews still free at the margin — and the multiplier settles at ~9x instead of ~18x. Still a rout; just an honest one. Need headroom instead? A CX32 (4 vCPU / 8 GB) at roughly €7–8/mo holds the whole stack plus previews with room to spare, and the comparison barely moves.

What disappears on the flat side is the entire metering apparatus: no per-dimension bill to itemize, no per-environment clone cost, no per-seat license, no per-backup line — and 20 TB of transfer that makes bandwidth arguments moot until you are genuinely large.

What is "pick your cloud per app" actually worth?​

Upsun's second pitch, beyond the meter, is choice: run each application on AWS, GCP, Azure, OVHcloud, or IBM Cloud per app, with data residency and compliance posture to match — SOC 2 Type 2, PCI DSS L1, ISO 27001, HIPAA on the badge wall, and even a 3% greener-region discount for picking a low-carbon region across Azure, AWS, GCP, and OVH. That is a real portfolio, and it is worth real money to three specific teams.

Worth it: regulated workloads that must cite a region and a certificate in a procurement document; agencies running one project per client where per-project isolation maps to per-client billing; platform teams whose branch-preview workflow (production-accurate clones per branch) is load-bearing and worth a per-environment meter.

Not worth it: a SaaS team with steady-state traffic, one compliance regime (or none yet), and previews that could live as namespaces on hardware they own. Per-app cloud choice is an option you pay for monthly whether you exercise it or not — and most months, the app sits in exactly one region on exactly one cloud, behaving identically to a container on a €4 box in Falkenstein.

The honest test is a question, not a spreadsheet: name the month you last moved an app between clouds to capture a real difference. If the answer is "never, but procurement likes that we could," you are buying an option, not infrastructure — price it as one.

The decision, without the sermon​

Stay on Upsun's meter when the bundle earns it: branch-preview velocity your team actually uses daily, compliance badges a contract actually requires, and a per-project shape where the €9 fee plus seats is noise next to the contract value. The meter is the price of zero-ops plus auditability, and for that team it is correctly priced.

Move to flat hardware when the bill scales with team habits instead of revenue: previews left warm, services sized for safety, seats added per hire, disk growing per environment — while the app itself would fit on one CX22 with 20 TB of headroom. That is the exact seam where a Cluster-API-managed fleet earns its keep: Git-push deploys and per-PR namespaces without a per-hour, per-GB, per-seat, per-backup meter running underneath.

Either way, recompute your own invoice with the four lines separated — project fee, app compute, service compute, storage plus backups — times your environment count, plus seats. If the total surprises you, that surprise is the finding.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Star the repo on GitHub or deploy your first app today.