Estimate Project

Serverless application development: what to build serverless, how it works, and what it costs

Summarize with ChatGPTSummarize with Perplexity
Two hands reach out of two phones toward each other across a cloud, with file, image and play icons and a globe above circuit lines

Serverless application development means building a backend from functions, small container services, and managed services such as databases, which a cloud provider runs and scales for you, so you do not manage servers and, with request-based billing, pay for the work they do. It fits stateless work that has uneven traffic and finishes within the platform's limit: 15 minutes for a standard AWS Lambda call, 60 minutes for a Cloud Run request.

This guide is for founders and CTOs who are deciding whether to build a backend serverless, or who are choosing a team to build it. It covers what serverless means in practice, where it helps and where it does not fit, which platforms besides the big clouds run functions, the design rules that keep it reliable, how a project runs, and what the work costs.

What serverless application development means

A serverless application runs its code when an event arrives: an HTTP request, a file upload, a new record in a database, or a time on a schedule. The provider runs the servers, the operating system, and the scaling; the team writes the code and describes the setup. A serverless app can combine three kinds of parts:

  • Functions: small pieces of code with one job each, such as AWS Lambda functions or Cloud Functions for Firebase. The Lambda limits and billing in this guide are for standard Lambda, which AWS calls the default compute type; Lambda Managed Instances, which run functions on EC2 instances in your account, have other limits and pricing.
  • Serverless containers: a whole service packed as a container image and run by a platform such as Google Cloud Run, which accepts code in any language that can be built into a container image.
  • Managed services: a database, sign-in, file storage, and queues that the provider runs, so the functions do not need servers of their own for them.

Functions and serverless containers overlap: Google built the second generation of Cloud Functions on Cloud Run and Eventarc, its service that delivers events from one Google Cloud service to another.

Benefits of serverless for application development

The main benefits are less infrastructure work for the team, scaling that follows requests, a bill that follows use, and separate releases for each part. They matter most for the parts of a product that have uneven traffic or one short, clear job.

  • No servers to patch: the provider maintains the servers under the code, and on Lambda's managed runtimes it also applies runtime updates by default, so the team spends its time on features.
  • Scaling per request: standard Lambda starts a separate copy of the function for each request it handles at the same time (on Lambda Managed Instances, one copy can handle several requests at once), up to the account's limit per region: 1,000 concurrent executions by default, and lower for new accounts.
  • Pay for use: a Lambda function is billed for the requests it handles and the time they take, not for the hours it waits for them.
  • Small, separate releases: each function or service can be deployed on its own, so a fix to the code that resizes images does not have to redeploy the code that handles webhooks.

When serverless is the wrong choice

Serverless is the wrong choice for work that runs longer than the platform allows, keeps state in memory, or carries a steady, high load on standard per-request Lambda. Such work belongs on long-running services, and deciding this before the build costs less than moving it later.

  • Long jobs: a Lambda function stops at its time limit. A video export or a large report is either split into steps or run as a Cloud Run job, whose tasks run to completion instead of answering a request. A job has a task timeout of 10 minutes by default, which can be raised.
  • Realtime features: chat and live updates keep a connection open for each user. In our Laravel projects, realtime runs on Laravel Reverb, a WebSocket server you run yourself as a long-running process. A backend that is otherwise serverless keeps such a server running next to it or hands realtime to a managed WebSocket service.
  • Steady, heavy traffic: when a service is busy all day, paying per request on standard Lambda stops saving money. Lambda Managed Instances are the exception AWS offers for steady, high-volume traffic: you pay for the EC2 instances plus a management fee, and AWS still runs the scaling and patching. Our guide to app hosting cost compares the serverless and container bills.

Serverless platforms compared: big clouds and edge platforms

Besides the function services of the big clouds, several platforms run functions next to a website or a database: Cloudflare Workers, Vercel Functions, Netlify Functions and Edge Functions, and Supabase Edge Functions. They differ from Lambda in three ways: how the code starts, how long it may run, and what the bill counts.

The biggest difference is the runtime model. Cloudflare Workers run code in V8 isolates, lightweight sandboxes created within an existing environment instead of a new virtual machine for each function; Cloudflare says this model “eliminates the cold starts of the virtual machine model.”

PlatformHow the code runsTime limitWhat the bill counts
AWS Lambda (standard)A separate environment per concurrent request, in the region you choose15 minutes per callRequests and the time they take
Cloud Run functionsBuilt into a container and run as a Cloud Run service, up to 1,000 concurrent requests per instanceUp to 60 minutes for HTTP functions, up to 9 minutes for event-driven ones created with the Cloud Functions v2 APICloud Run pricing
Azure Functions, Flex Consumption planScales to zero; optional always-ready instances shorten cold starts30 minutes by default, no fixed maximum; an HTTP function has to respond within 230 secondsExecution time and executions, plus always-ready instances if you turn them on
Cloudflare WorkersV8 isolates on Cloudflare's global network; JavaScript, TypeScript, and Python, plus Rust in betaCPU time, not waiting time: 10 ms per request on the free plan, 30 seconds by default and up to 5 minutes on the paid planRequests and CPU time, with no charge for duration
Vercel FunctionsNode.js, Bun, Python, and other runtimes; on Node.js and Python, several requests can share one instance; one region by default300 seconds by default, up to 800 seconds on Pro and Enterprise plans (30 minutes in beta)Active CPU time, provisioned memory, and invocations
Netlify FunctionsDeployed with the site; one region by default, US East (Ohio)60 seconds per request, 30 seconds for scheduled functions, 15 minutes for background functionsRun time multiplied by memory, in GB-hours, on credit-based plans
Netlify Edge FunctionsA Deno-based runtime at the network location closest to each user50 ms of CPU time per request; response headers within 40 secondsInvocations, with a monthly allowance that depends on the plan
Supabase Edge FunctionsA Deno-compatible runtime distributed globally at the edge; functions commonly call Supabase's database, storage, and sign-in2 seconds of CPU time per request; a worker stays up 150 seconds on the free plan, 400 on paidInvocations above the plan's quota

Two platforms changed recently. Vercel now recommends moving from its Edge runtime to Node.js, and both run on the same fluid compute model. Deno rebuilt Deno Deploy as a platform for whole JavaScript and TypeScript apps, Node and Next.js apps included.

When each kind of platform fits

  • Big-cloud functions: when the database, queues, and files of the product already live in that cloud, and for jobs that take minutes rather than milliseconds.
  • Cloudflare Workers and edge functions: short code that runs on every request close to the user, such as redirects, sign-in checks, localized content, or header changes. Their CPU limits make them a poor fit for heavy processing.
  • Vercel and Netlify Functions: the API routes and form handlers of a frontend hosted on the same platform, released together with the site.
  • Supabase Edge Functions: webhooks and small endpoints for a product that already keeps its data and sign-in in Supabase.

Running near the user helps less when the code waits on a database far away. Vercel's guide to function regions notes that the distance between a function and its data source can affect latency, and lets you run functions close to the database. Each of these platforms also has its own configuration and APIs, so moving off one later means rewriting that layer.

How we split a product between serverless and long-running services

In our Google Cloud setup, the core, with its business rules, accounts, and payments, usually runs as a Laravel backend in containers on Google Kubernetes Engine (GKE), with a PostgreSQL database. Simple services and APIs that answer a request and keep nothing between requests run on Cloud Run, which scales them to zero when they are idle.

The split follows the work each part does:

Part of the productWhere it runsWhy
Business rules, accounts, payments, admin APILaravel backend in containers on GKESteady work that needs more control over resources
Webhook handlers, form endpoints, small APIsCloud RunShort, stateless requests with uneven traffic
Production databaseCloud SQLGoogle runs backups and updates
User filesCloud StorageStorage grows with the data, apart from the compute

Design rules for a serverless backend

A serverless backend stays reliable when every function can run twice, stop at any moment, and start on a fresh instance without losing data. On Lambda, for example, an event sent asynchronously can arrive more than once, an environment can end for updates, and a call stops at its time limit. These rules turn that into code:

  • Keep no state in memory: Lambda reuses a function's environment between calls, but it also ends environments every few hours for updates. Anything that must survive goes to a database or file storage.
  • Make every handler idempotent: running it twice gives the same result as running it once. AWS says a function called asynchronously can receive the same event more than once, and by default Lambda runs a failed call two more times. Firebase describes at-least-once execution of event-driven functions; by default a failed run may not be retried, and turning on retries makes Firebase repeat it.
  • Plan around time limits: 15 minutes for a Lambda call; for a Cloud Run request, 5 minutes by default and up to 60 minutes. Longer work is split into steps or moved to a job.
  • Control database connections: standard Lambda handles each concurrent request in its own environment, so a traffic spike opens many connections at once. RDS Proxy on AWS keeps a pool of connections and reuses them. A Cloud Run instance can be set to take up to 1,000 requests at once, so requests on the same instance can share its connections.
  • Expect slow first requests: a cold start is the wait while the provider prepares a new environment. AWS says cold starts typically occur in under 1% of calls and last from under 100 ms to over 1 second. Loading only the libraries a function needs shortens them.
  • Give each service only the access it needs: on Cloud Run, a service runs under the service account set when it is deployed, so its permissions can be limited to what that service needs, and no static keys are stored in the code.
  • Watch for loops that bill you: a function that writes to the queue or bucket that triggers it calls itself again and again, and pay-per-use pricing has no ceiling. Lambda stops such a loop after about 16 invocations, but only when it runs through SQS, S3, SNS, or EventBridge custom event buses; a loop through DynamoDB, for example, keeps running. AWS recommends alarms on unusual invocations and on spending; set them up before launch.
  • Watch how long messages wait: a queue in front of a function absorbs a short spike, but it adds no capacity when the database or an external API behind the function is the limit. A small, steady overload can build a wait of minutes while the function's own duration still looks normal, because that duration leaves out the time a message spent in the queue. On SQS, set an alarm on ApproximateAgeOfOldestMessage, the age of the oldest unprocessed message, and decide before launch what happens in a long peak: reject the extra work, add capacity, or accept the delay.
  • Price AI calls by the wait: a function that sends a prompt to a language model sits idle until the answer comes back. Standard Lambda bills that wait as duration, while Cloudflare Workers bill CPU time and charge nothing for duration, so the same AI feature can cost very different amounts on the two platforms. Estimate the bill from the model's response time, not from the code's own work.

“Tests usually send each event once, so a function that breaks on a second delivery still passes them. That is why, in a review, I check more than the handler's logic: I look at the point where it records that the work is done. If a repeat can arrive between the work and that record, the function needs a plan for that gap before it ships.”

Alexander Storozhevsky, Lead developer at Ronas IT

Example: the forms on our own website

The forms on ronasit.com run on serverless functions. When someone sends the contact form, one function receives it and saves it as a document in Firestore, the document database of Firebase. Creating that document triggers a second function, which checks the submission for spam and creates a lead in our CRM, usually within seconds. A scheduled function runs every 30 minutes and picks up any submission older than 10 minutes that has not reached the CRM yet, in case the trigger failed. Each document carries a flag that records whether its lead was created. The code reads the document again just before it creates a lead, so a repeated trigger or the sweep skips a submission once its flag is set. Another scheduled function runs every 5 minutes and sends the thank-you emails.

The lesson is that an event-driven function can miss an event or receive it twice, so the design has to handle both: here, the scheduled sweep picks up a missed event, and the flag stops a repeat that arrives after it is saved.

How a serverless application development project runs

A serverless project runs like other backend work at Ronas IT, with one extra decision early on: which parts run serverless and which run as long-running services.

  1. Estimate and scope: a rough estimate costs you nothing. If there is no written scope yet, a paid analysis phase turns the idea into user stories and a reviewed architecture, and you receive a written scope with a budget and a timeline.
  2. Architecture: the tech lead decides which parts run serverless, using the rules above, as part of the technical plan.
  3. Infrastructure as code: a DevOps engineer describes the environments in Terraform, based on our open-source modules for Google Cloud and AWS. Our projects start in your own cloud account.
  4. Development in sprints: sprints usually take one to three weeks, and you see the result of each one, such as an update on the development server. On our own website, developers run the functions on their machines with the Firebase Local Emulator Suite, which emulates Firestore and the functions.
  5. Tests and release: our backend standard asks for a test with every change, and the pipeline builds a release only after the tests pass.
  6. Monitoring after launch: it runs under a monthly plan, either DevOps and hosting or support, and on Google Cloud, alert policies can be described in Terraform together with the services.

What serverless application development costs

At Ronas IT, serverless services without a web interface, for a frontend your own team builds, start from $2,500 and 2 weeks. A product with its own web interface starts from $5,000 and 2 weeks as a basic MVP. Both prices already include project management, testing, the integrations the services need, and automated deployment, and the basic MVP also includes its design. Keeping the environments running and monitored after launch is a monthly DevOps and hosting plan, and new infrastructure, such as a move to the cloud, is estimated separately. The cloud bill is separate and goes to your own cloud account. These are our standard prices:

WorkPriceTimeline
Analysis phase, optional, when the scope is not written down yet$1,000-$2,000At least 1 week
Backend and API, for an API or serverless services without a web interface, including integrations such as payments or a CRMFrom $2,500At least 2 weeks
Basic MVP, for a product with a web interface and a serverless or mixed backendFrom $5,000At least 2 weeks
Complex product, such as a SaaS with high load or real-time featuresFrom $20,000At least 8 weeks
DevOps and hosting after launch: environments, releases, and monitoring of the live projectFrom $200 per monthOngoing
Support after launch: monitoring, fixes, and updates of the live productFrom $1,000 per month for one app, from $2,000 for a system of several appsOngoing

Serverless removes server setup and patching for the parts it runs, and it adds design work for retries and time limits. To see how the monthly cloud bill grows with traffic, read our guide to app hosting cost.

How to choose a serverless application development company

Choose a team that tells you which parts of your product should not be serverless. Then check these points:

  • Where it runs: production in a cloud account that you own, with the infrastructure described as code that stays with you.
  • A split by workload: an architecture that names what runs serverless, what runs as long-running services, and why.
  • Retries and duplicates: ask how a function that sends an email or takes a payment behaves when the same event arrives again or the call fails.
  • Tests before release: local emulators or test environments, and tests that must pass before a release is built.
  • Monitoring: who watches the functions after launch, and how a failure reaches the team.

What to do next

  1. List the parts of your backend: mark each one as short and stateless, or long-running and stateful.
  2. Check each serverless candidate: compare its longest task with the time limit of your platform, and count the database connections it will open.
  3. Decide what a repeated event does: for every handler, write down the result of running it again on the same event.
  4. Get a rough estimate: request one, or request an analysis phase when your scope is not in writing yet.

Tell us what your product does and which parts you plan to run serverless. We will reply with a rough estimate for building it.

Frequently Asked Questions (FAQs)

What is a serverless application?

It is an application whose backend runs as functions or container services that a cloud provider starts when an event arrives, scales with the number of requests, and stops when there is no work. Servers still exist, but the provider runs them, so the team does not set up, patch, or size them.

Is serverless a good fit for a mobile app backend?

It can run parts of one, such as an endpoint behind a sign-up form, a job that processes uploaded photos, or scheduled reminders. When the app has payments, user roles, and links to your own systems, we build its core as a custom Laravel backend and put simple services around it on serverless. Our mobile app backend guide compares a custom backend with ready-made backend services.

How do you test a serverless application?

In layers. Developers run functions on their own machines against local emulators of the cloud services. Integration tests walk a whole user scenario and replace calls to third-party APIs with test doubles, so a vendor outage does not break the test run. Then the change goes to a development environment in the cloud, where the real triggers and permissions apply.

Does serverless lock you into one cloud provider?

Partly. Event triggers, function settings, and managed services differ between AWS, Google Cloud, and Azure, so the more of them an app uses, the more of it changes in a move. Code packed as a container image is easier to move, because it runs anywhere a container can run, Cloud Run included. Describing the setup in Terraform keeps it readable for the next team.

Which serverless platform should I choose?

Usually the one where the rest of your product already runs, because functions work best next to the database and services they call: AWS Lambda on AWS, Cloud Run services or Cloud Run functions on Google Cloud, Azure Functions on Azure. We keep Terraform modules for AWS and Google Cloud, and our ready-made Google Cloud setup runs simple services on Cloud Run. For short code that has to run on each request close to the user, such as a redirect, an edge platform like Cloudflare Workers is the lighter option.

How do you monitor a serverless application?

Each function writes logs to the provider's logging service, such as Cloud Logging on Google Cloud. Metrics built from those logs, together with alert policies, turn repeated errors or slow calls into an alert for the team. Our Terraform modules for Google Cloud include both, so these alerts can be described in code together with the services.

Can I move an existing backend to serverless?

Yes, part by part. Start with the work that already fits: webhook handlers, scheduled tasks, and file processing. Leave the parts that keep state or run all day where they are, and move each piece only after it handles a repeated event safely and finishes within the platform's time limit.

Related posts

A server rack on one side of a lightning split and a crane hook lowering a shipping container onto a cloud on the other
Tech
How much does it cost to host an app: the cloud bill, serverless vs containers, and upkeep
2026-11-17 • 14 min read
A smartphone connected by a cable to a server rack, with a database, a padlock, a notification bell, and a user icon around it
Tech
Mobile app backend: what it does, when your app needs one, and what it costs
2026-11-17 • 15 min read
A developer types on a laptop in front of a window with curly braces, linked to a server stack, with a phone, a gear and a rising chart
How to
API development services: scope, process, security, and cost
2026-11-17 • 15 min read
A smiling cat sips a cocktail while robot arms adjust gears on a computer screen and handle profile cards
How to
DevOps automation services: what they cover, tools, cost, and how to choose
2026-11-19 • 12 min read
The Ronas IT cat mascot holds a wrench by three rising steps with a laptop, a gear and conveyor with a box, and a cloud with a shield
How to
DevOps for startups: what to set up at each stage, who owns it, and what it costs
2026-11-19 • 13 min read