How much does it cost to host an app: the cloud bill, serverless vs containers, and upkeep

Hosting an app costs two things: the monthly bill from the cloud provider and the work to keep the setup running. For our ready-made Google Cloud setup, with its database and file storage, a very rough estimate puts the starting cloud bill in the range of $50-$70 a month at very low usage. The bill grows with traffic, stored data, and the number of environments. The work is billed apart from it, in two lines: DevOps and hosting from $200 per month for the infrastructure, and support, which starts at $1,000 per month when the product is a single app with its backend and admin panel, or at $2,000 when several client apps share that backend.
This guide is for founders and product owners who need a hosting line in their budget before the backend is built. It explains what a cloud bill is made of, how each hosting model charges, when serverless costs less than containers, what managed platforms and backend-as-a-service cost, and how to keep the bill predictable.
What goes into an app hosting bill
A cloud bill is a list of metered services, and the app's backend decides which of them appear. For a web or mobile app with its own backend, the bill usually has these lines:
- Compute: the servers, containers, or functions that run the backend code. Depending on the model, you pay for capacity by the hour or for each request and the seconds it takes.
- Database: a managed database, such as Cloud SQL on Google Cloud, billed for the size of the instance and the data it stores.
- File storage: photos, documents, and backups, billed for the space used and the operations on it.
- Outbound traffic: the data the app sends to users over the internet, billed per gigabyte after a small free allowance.
- Environments: a production environment for users and a development environment for the team. Each one uses its own resources.
- Third-party services: email delivery, maps, push notifications, and payments come from their own vendors, with their own pricing.
How each hosting model charges
The hosting model decides how you pay: for capacity that runs all month, for the requests the app actually serves, or through a plan fee with metered usage on top. Usage prices depend on the region: the Lambda request price is for US regions, and the Cloud Run allowance is based on its prices in Iowa (us-central1).
| Hosting model | Example | How you pay | Base charge and free allowance |
|---|---|---|---|
| Containers on a managed Kubernetes cluster | Google Kubernetes Engine | A cluster fee, plus the nodes the containers run on, billed until the nodes are deleted | $0.10 per cluster per hour, or $74.40 for a 31-day month, while its Kubernetes version is in standard support. A monthly credit of $74.40 per billing account covers the fee of one zonal or Autopilot cluster; compute is billed on top. |
| Containers on a managed Kubernetes cluster | Amazon EKS | A cluster fee, plus the servers the containers run on | $0.10 per cluster per hour while its Kubernetes version is in standard support |
| Serverless containers | Google Cloud Run | CPU and memory used, rounded up to the nearest 100 milliseconds; with request-based billing, also each request | With request-based billing, 2 million requests, 180,000 vCPU-seconds, and 360,000 GiB-seconds of memory free per month |
| Functions | AWS Lambda | Each request, plus run time measured in GB-seconds | $0.20 per 1 million requests. 1 million requests and 400,000 GB-seconds free per month |
| Managed app platform | Vercel | A plan fee, plus metered usage beyond what the plan includes | A Pro plan fee that includes a monthly usage credit; prices are in the list of platforms below |
No row is a full bill. A database, file storage, and outbound traffic come on top of any hosting model, and a cluster also needs the compute its containers use.
Serverless vs containers: which costs less to run?
Serverless with request-based billing costs less for services with low or uneven traffic, because the bill follows requests and stops when the service is idle. Containers on a cluster suit the parts of a product that work all the time, where steady work uses the capacity you pay for. Our Google Cloud setup uses both: GKE for the complex parts and Cloud Run for simple services, so no single cluster is sized for the heaviest workload and paid for every hour.

Where serverless fits
- Simple, stateless services: an API behind a form, a webhook handler, or a job that resizes uploaded images. Each request is handled on its own, and nothing has to stay in memory between requests.
- Low or uneven traffic: with request-based billing, a service that is busy for an hour a day, or only after a marketing email, is billed for that hour instead of a full day.
Serverless has one cost that the per-request price hides: the first request after a quiet period waits for a new instance to start. Google Cloud and AWS both sell a fix, and both bill for it. Cloud Run can keep a minimum number of instances running and, with request-based billing, bills them at a lower rate while they wait. AWS Lambda Provisioned Concurrency is paid for as long as it is switched on, and the Lambda free tier does not apply to functions that use it.
“Before I pay to keep an instance running for a serverless service, I ask who sees the slow start. If it is a user on a sign-up or payment screen, the wait is worth paying to avoid. If it is an internal tool or a background job, nobody notices it, and the service can stop when idle. Kept on every service, these instances bring back the idle bill that serverless was supposed to cut.”
Alexander Storozhevsky, Lead developer at Ronas IT
Where containers on a cluster fit
- Complex parts that work all the time: microservices, queues, and services that keep state or hold open connections. They need more control over resources than a serverless platform gives.
- Easier moves between providers: containers on Kubernetes move between Google Cloud, AWS, and Azure with fewer changes than code written for one provider's functions. Storage, load balancers, and sign-in that rely on a provider's own services still need adapting to the new cloud.
Where one VM with Docker Swarm fits
A small product with one API, one web app, and a few background jobs does not need a cluster. We run such a product in production on Docker Swarm on one cloud virtual machine (VM) in your account. That machine still runs all month, but there is no cluster fee and no group of nodes to keep running. The database stays on the cloud provider's managed database service, a separate line on the bill. When the product grows into several services or its load starts to change, it can move to Kubernetes.
The pipeline that tests and builds the code does not leave an idle charge either. Each of its jobs gets a new cloud machine that is deleted when the job ends, so between pipelines there are no CI machines to pay for.
Managed app platforms and backend-as-a-service
A prototype, a marketing site, or an early MVP can skip the cluster and run on a managed platform: you connect the Git repository, and the platform builds, deploys, and scales the app. Here is how the main options charge:
- Front ends with serverless functions: the Vercel Pro plan costs $20 per month and includes one deploying seat and $20 of usage credit, and new teams get a default on-demand budget of $200 that you can change. Netlify Pro starts at $20 per month for unlimited members, and each Pro tier comes with monthly credits that metered features draw from.
- Code at the network edge: Cloudflare Workers on the paid plan has a minimum charge of $5 per month per account, which includes 10 million requests and 30 million CPU milliseconds a month; usage above that is billed per million.
- Containers and long-running services: a free web service on Render spins down after 15 minutes without traffic, so paid instances are the option for a live product. Fly.io has no monthly platform fee and bills machines by the second while they run. Railway also bills by the second, and its Hobby plan includes $5 of usage a month.
- Backend-as-a-service: Supabase gives a Postgres database, sign-in, and file storage under one bill. Its Pro plan is $25 per month and includes $10 of compute credits, enough for one Micro instance.
For a product with modest traffic, a plan and its usage can cost less than a cluster, and the platform takes over deployments and scaling. The limits show up as the product grows. Serverless functions on these platforms limit the run time or CPU time of each request, so check how a platform handles long background jobs before you build on it. Usage charges climb with traffic, so set the platform's spend limits before a busy launch. And code written against a backend-as-a-service's API has to be rewritten for a later move to your own backend.
What makes the hosting bill grow
The bill grows with what the backend does, not with the number of screens in the app. These are the drivers to plan for before launch:
- Traffic and background work: more requests mean more billed processing time on serverless, and more or larger machines in a cluster.
- Stored files: storage is billed for space and operations. Files that are rarely opened can move to cheaper storage classes, which on Google Cloud Storage are Nearline, Coldline, and Archive.
- Separate databases: in the neobank app we built for a US client, each service has its own database that stores only the data it needs. Each database that runs as its own managed instance adds its own line to the bill, so this design fits products with regulated data, such as banking, where limiting what each database holds is worth the extra cost.
- Test environments: an environment for each feature branch or demo uses resources while it exists. We create such environments on demand and delete them after use, as separate namespaces inside one cluster or, when stricter isolation is needed, as separate clusters; namespaces in one cluster often cost less than a cluster each.
- Availability: a regional GKE cluster keeps copies of its control plane in several zones of a region and by default spreads its nodes across them, so the control plane keeps working if one zone fails. A regional Standard cluster pays the full cluster fee from the table above. How much uptime to pay for is a business decision. In an essay on uptime guarantees, Itzy notes that 99.99% uptime allows 50 times less downtime than 99.5%, and that guaranteeing it takes redundant infrastructure and round-the-clock operations. The essay calls 99.5% the cost-effective target for most startups. Before you pay for another nine, estimate what an hour of downtime costs your business.
- Traffic between zones: spreading services across zones also adds a network line, because the provider bills data that moves between zones. The Skeepers engineering team reported in 2023 that inter-zone traffic cost it about €2,712 per month on Google Cloud. Most of it came from a GraphQL gateway that called its 40-plus services, and caching the busiest endpoints in Redis brought that line down to about €1,095.
- AI features: a feature that calls a hosted model adds the model provider's usage bill, charged for the text that goes in and out, as our guide to generative AI integration explains. A model you run yourself needs a GPU instead, and it is billed differently from the rest of the setup. On Cloud Run, a service with a GPU must use instance-based billing, the GPU is billed for the whole life of each instance, and minimum instances are charged at the full rate even when idle. The cheaper idle rate for warm instances from the serverless section does not apply here, so keep a GPU warm only where users wait for its answer.
Hosting is only part of the running cost
The cloud bill pays for the resources the app uses. Someone also has to update the setup, watch it, and fix it when something fails, and that work is its own budget line. At Ronas IT it is priced like this:
- DevOps and hosting: from $200 per month for one project: its hosting, environments, deployment pipelines, monitoring, and tuning to cut unneeded costs on your cloud bill. The fee covers an engineer who watches your project's health with AI agents.
- App support: from $1,000 per month for a single app, its backend and admin panel included, with availability monitoring, fixes for technical issues, and OS and SDK updates.
- Support of the whole system: from $2,000 per month for a live product with several client apps, such as a web app and mobile apps, with the same monitoring, fixes, and updates. Cloud cost tuning is part of DevOps and hosting, not support.
- Cloud migration: estimated by scope when an existing app moves to the cloud; our guide to cloud migration cost covers that project.
When we build a new product, setting up its first environment and automated deployment is part of the build estimate, so it is not a separate project. What DevOps work includes is described on our DevOps automation services page, and the tools we use are in our guide to DevOps automation.
Who pays the cloud bill
You do, directly to the provider. Production runs in your own cloud account, so the provider bills you for it and every line of that bill is visible to you, not hidden inside our invoice.
We describe the infrastructure as code with Terraform and Terragrunt. In our Google Cloud setup, that code lives in your Git repository, or in our GitLab until you ask us to transfer it, so any team that knows Terraform and Google Cloud can read what runs and what it costs.
How to keep the hosting bill predictable
A surprise in a cloud bill can come from a resource nobody watches.

These habits keep the bill close to the plan:
- See costs from the first day: when we run a product on Kubernetes, the cluster ships with a cost monitor, so you can see what each service in the cluster costs before the first large bill arrives.
- Set requests and limits for each container: each service gets a defined share of CPU and memory, so one service cannot use up what the others need, and the cluster is sized to real use. Compare the requests with measured use: a cluster adds nodes for what pods request, not for what they use. In the same Skeepers report, pods requested about 0.4 GB of memory while using about 0.1 GB, and services kept at least three pods running even at night. Lowering the requests and keeping one minimum replica where that was safe cut the monthly node cost from about €4,235 to about €1,973.
- Let simple services stop when idle: set minimum instances only where a slow first request would hurt users.
- Delete what nobody uses: temporary environments for tests and demos go away when the work is done.
- Review performance against cost: after launch, this check is recurring work in our standard setup, together with security patches.
What to do next
- List what the backend runs: services, databases, file storage, and scheduled jobs, with how busy each one is during a day.
- Match each part to a model: steady and complex parts to containers on a cluster, simple and occasional ones to serverless.
- Budget three lines: the monthly cloud bill in your own account, the DevOps and hosting plan for environments, deployment pipelines, and infrastructure monitoring, and support for fixes and updates to the product itself.
- Turn on cost monitoring before launch: it is cheaper to fix a wrong size in the first week than after a quarter of bills.
Frequently Asked Questions (FAQs)
How much does it cost to host an app per month?
It depends on traffic, stored data, and the number of environments. Our ready-made Google Cloud setup runs the core on Google Kubernetes Engine (GKE), simple services on Cloud Run, the database on Cloud SQL, and files on Cloud Storage. By a very rough estimate, its monthly cloud bill starts in the range of $50-$70 when usage is very low. We choose the setup for each project, and a smaller product often runs on one cloud VM with Docker Swarm instead. DevOps and hosting, from $200 per month, and support of one app, from $1,000 per month, are priced separately from the cloud bill.
Is serverless cheaper than containers?
For a service that is idle most of the day or gets traffic in bursts, it usually is: serverless bills for requests and processing time, and Cloud Run with request-based billing and no minimum instances is not billed while its instances are idle. Our Google Cloud setup uses both: containers on a GKE cluster, sized to the traffic, for the parts of a product that keep working between requests, and Cloud Run for simple services.
When should I use serverless vs containers?
Use serverless for simple services that answer a request and keep nothing between requests, such as an API behind a form or a job that resizes uploaded images. Use containers on a cluster for the complex parts that need more control and steady work, such as microservices and services that keep state.
How much does AWS hosting cost for an app?
AWS bills each service on its own. An Amazon EKS cluster costs $0.10 per hour during standard support of its Kubernetes version, before the servers the containers run on. In US regions, AWS Lambda charges $0.20 per 1 million requests plus run time, after a monthly free tier of 1 million requests and 400,000 GB-seconds. The AWS Pricing Calculator adds up an estimate for a whole setup.
Which cloud is cheapest for hosting a SaaS app?
No provider is the cheapest for every app, because each prices compute, databases, and traffic differently. We build on Google Cloud and AWS and keep Terraform modules for both. Your credits, your team's experience, and the managed services the product needs can matter more for the choice than a small difference in unit prices.
Who pays for hosting when an agency builds my app?
You pay the cloud provider directly: production runs in your own cloud account, so its bill comes to you and you see every line of it. Our work to set up and run the infrastructure is billed separately from the cloud bill.
What is app hosting?
App hosting is the cloud infrastructure that runs the server side of an app: the servers, containers, or functions that answer requests, the database, file storage, and the network that sends data to users. A mobile app itself is installed from the App Store or Google Play; hosting runs the backend it talks to.
Can a free tier cover a real product?
The GKE, Cloud Run, and AWS Lambda free tiers do not cover a managed database or file storage. The GKE free tier credit pays the fee of one zonal or Autopilot cluster, but not the compute its workloads use. Cloud Run and AWS Lambda free tiers reset every month, and usage beyond them is billed.






