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

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.”
| Platform | How the code runs | Time limit | What the bill counts |
|---|---|---|---|
| AWS Lambda (standard) | A separate environment per concurrent request, in the region you choose | 15 minutes per call | Requests and the time they take |
| Cloud Run functions | Built into a container and run as a Cloud Run service, up to 1,000 concurrent requests per instance | Up to 60 minutes for HTTP functions, up to 9 minutes for event-driven ones created with the Cloud Functions v2 API | Cloud Run pricing |
| Azure Functions, Flex Consumption plan | Scales to zero; optional always-ready instances shorten cold starts | 30 minutes by default, no fixed maximum; an HTTP function has to respond within 230 seconds | Execution time and executions, plus always-ready instances if you turn them on |
| Cloudflare Workers | V8 isolates on Cloudflare's global network; JavaScript, TypeScript, and Python, plus Rust in beta | CPU time, not waiting time: 10 ms per request on the free plan, 30 seconds by default and up to 5 minutes on the paid plan | Requests and CPU time, with no charge for duration |
| Vercel Functions | Node.js, Bun, Python, and other runtimes; on Node.js and Python, several requests can share one instance; one region by default | 300 seconds by default, up to 800 seconds on Pro and Enterprise plans (30 minutes in beta) | Active CPU time, provisioned memory, and invocations |
| Netlify Functions | Deployed with the site; one region by default, US East (Ohio) | 60 seconds per request, 30 seconds for scheduled functions, 15 minutes for background functions | Run time multiplied by memory, in GB-hours, on credit-based plans |
| Netlify Edge Functions | A Deno-based runtime at the network location closest to each user | 50 ms of CPU time per request; response headers within 40 seconds | Invocations, with a monthly allowance that depends on the plan |
| Supabase Edge Functions | A Deno-compatible runtime distributed globally at the edge; functions commonly call Supabase's database, storage, and sign-in | 2 seconds of CPU time per request; a worker stays up 150 seconds on the free plan, 400 on paid | Invocations 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 product | Where it runs | Why |
|---|---|---|
| Business rules, accounts, payments, admin API | Laravel backend in containers on GKE | Steady work that needs more control over resources |
| Webhook handlers, form endpoints, small APIs | Cloud Run | Short, stateless requests with uneven traffic |
| Production database | Cloud SQL | Google runs backups and updates |
| User files | Cloud Storage | Storage 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.

- 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.
- Architecture: the tech lead decides which parts run serverless, using the rules above, as part of the technical plan.
- 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.
- 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.
- Tests and release: our backend standard asks for a test with every change, and the pipeline builds a release only after the tests pass.
- 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:
| Work | Price | Timeline |
|---|---|---|
| Analysis phase, optional, when the scope is not written down yet | $1,000-$2,000 | At least 1 week |
| Backend and API, for an API or serverless services without a web interface, including integrations such as payments or a CRM | From $2,500 | At least 2 weeks |
| Basic MVP, for a product with a web interface and a serverless or mixed backend | From $5,000 | At least 2 weeks |
| Complex product, such as a SaaS with high load or real-time features | From $20,000 | At least 8 weeks |
| DevOps and hosting after launch: environments, releases, and monitoring of the live project | From $200 per month | Ongoing |
| Support after launch: monitoring, fixes, and updates of the live product | From $1,000 per month for one app, from $2,000 for a system of several apps | Ongoing |
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
- List the parts of your backend: mark each one as short and stateless, or long-running and stateful.
- Check each serverless candidate: compare its longest task with the time limit of your platform, and count the database connections it will open.
- Decide what a repeated event does: for every handler, write down the result of running it again on the same event.
- Get a rough estimate: request one, or request an analysis phase when your scope is not in writing yet.
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.





