When a developer tells you the contact form "runs on a Netlify function" or the order lookup "is a Vercel function", there is a good chance the code is executing on AWS Lambda, Amazon's pay-by-the-millisecond compute service. You never see an AWS bill. You see your host's bill, priced in its own units, with Lambda somewhere underneath.
That is not a scandal. It is a normal reseller arrangement, and for most small businesses it is the right one. But knowing the base rate is useful. It tells you what you are paying for the convenience, which of your host's meters actually move your bill, and when a function you wrote for a few cents a month quietly turns into a line item. This post works through Lambda's own price list, the platforms that say in their own words that they build on it, how they price it to you, and the same workload priced five ways with the arithmetic shown.
If you are still choosing a host for a new site, read What Hosting a New Business Site Actually Costs in 2026 first. This one goes a layer down.
What Lambda is, in four numbers
You upload a function. AWS runs it when something calls it (a web request, a file landing in storage, a schedule) and bills you for two things: the number of requests, and memory multiplied by the time the function ran, measured in GB-seconds.
From AWS's own pricing page, for x86 in US East (N. Virginia), first pricing tier:
- $0.20 per million requests.
- $0.0000166667 per GB-second. Multiply by 3,600 and that is $0.06 per GB-hour. Keep that number; it is the yardstick for everything below.
- A monthly free tier of one million requests and 400,000 GB-seconds. A lot of small workloads never leave it.
- Memory from 128 MB to 10,240 MB, with CPU handed out in proportion. AWS's documentation puts one full vCPU at 1,769 MB, so a 128 MB function gets roughly 7 percent of a processor.
Two newer details matter for the bill. Since August 1, 2025, AWS bills the initialization phase (the "cold start" when a fresh copy of your function boots) for on-demand functions packaged as ZIP files, which used to be free in that configuration. And Lambda bills wall-clock time: if your function spends 180 of its 200 milliseconds waiting for a database or an AI model to answer, you pay for all 200.
Lambda is one product inside a very large business. Amazon reported AWS segment sales of $46.0 billion for the third quarter of 2026, up 39 percent year over year, with $17.8 billion of operating income. Amazon reports AWS as one segment and does not break out Lambda.
Who builds on Lambda, in their own words
Netlify. When Netlify launched Functions in March 2018, its announcement said you could "deploy serverless AWS Lambda functions on Netlify without configuring API gateways, coordinating deployments, or setting up an AWS account." That sentence is the whole business model in one line. Netlify's current overview page no longer describes the platform that way, but its configuration rules still are Lambda's: the Node.js version for your functions "must be a valid AWS Lambda runtime for Node.js", and you override it with an environment variable literally named AWS_LAMBDA_JS_RUNTIME. The same page lists the current limits: 60 seconds for a normal function, 30 seconds for a scheduled one, 15 minutes for a background one, and 1,024 MB of memory by default.
Vercel. In a July 2025 engineering post explaining its newer "Fluid compute" model, Vercel wrote plainly: "Vercel Functions run on AWS Lambda". The post is about how Vercel layered its own scheduling on top so one running instance can serve several requests at once, which is what makes its pricing different (more on that below).
Zapier. If you have ever added a "Code by Zapier" step to an automation, Zapier's help center says where it runs: "The environment in which your Code steps run (AWS Lambda) has an I/O limit of 6 MB."
Tools that put Lambda in your own AWS account. Not everyone resells. The Serverless Framework started as a way to deploy to AWS Lambda, and its current terms make the CLI free "except for organizations earning over $2 million annually". SST is open source and creates the infrastructure in your own AWS account. With these, you pay AWS directly and the tool vendor sells convenience, dashboards or support rather than compute.
Big direct customers. AWS's serverless economics whitepaper (which AWS now marks as historical reference) lists FINRA using Lambda to run "half a trillion data validations on 37 billion stock market events daily", Toyota Connected handling "18 billion transactions per month", and Fannie Mae scaling "up to 15,000 concurrent function executions during testing". These are the workloads that make Lambda's per-millisecond model pay off: huge, spiky and parallel.
How the resellers make money
There are four places, and compute is the smallest of them.
1. The plan floor
You pay a monthly fee whether or not a function ever runs. Netlify's Personal plan is $9 a month with 1,000 credits; Pro is $20 a month with 3,000 credits and unlimited members. Vercel Pro is $20 a month and includes $20 of usage credit. For a small site the plan fee is usually most of the bill, and the included allowance is designed so that most customers never exceed it.
2. A different meter for the same compute
Netlify bills compute in credits: "Compute consumes 10 credits per GB-hour", measured against the memory your functions are allocated, with no per-invocation charge. If you value a credit at what the plan charges for it, that is $20 / 3,000 x 10 = $0.067 per GB-hour on Pro and $9 / 1,000 x 10 = $0.09 per GB-hour on Personal, against Lambda's $0.06 list. That is a markup of 11 to 50 percent before whatever volume pricing Netlify negotiates with AWS, which is not public.
The bigger lever is the memory, not the rate. Netlify runs functions at 1,024 MB by default, the allowed range is 1,024 to 4,096 MB (and changing it at all is a credit-based Pro or Enterprise feature), and its docs say billing "scales linearly with the configured size". Lambda's smallest size is 128 MB. So a tiny form handler that would fit in 128 MB on raw Lambda is metered at eight times the memory on Netlify, and there is no setting to bring it down. On Netlify the lever you control is duration.
Vercel split the meter in two: Active CPU at $0.128 per CPU-hour, plus provisioned memory at $0.0106 per GB-hour, plus $0.60 per million invocations (Washington D.C. and the other cheapest regions). The key sentence in its docs: "Vercel bills Active CPU only while your code is actually running. If the request is waiting on I/O, CPU billing pauses but memory billing continues."
Put both on the same footing, one vCPU with Lambda's matching 1,769 MB of memory:
Scroll to compare columns and rows when the table extends beyond the box.
| While computing | While waiting on a network call | |
|---|---|---|
| Raw Lambda (1.769 GB x $0.06) | $0.106 per hour | $0.106 per hour |
| Vercel (CPU $0.128 + 1.769 GB x $0.0106) | $0.147 per hour | $0.019 per hour |
So Vercel charges about 39 percent more than raw Lambda for pure computation, and about 82 percent less for time spent waiting. That is not an accident. Vercel buys Lambda-shaped capacity, packs several waiting requests into one instance, and sells you a meter Lambda itself does not offer. For a site whose functions mostly call an AI model or a database and wait, that meter can undercut going to AWS directly.
3. The rest of the bill
On Netlify's credit plans, bandwidth is 20 credits per GB, web requests are 2 credits per 10,000, and every successful production deploy costs 15 credits. For most small sites these, not functions, are what move the bill.
4. What you are actually buying
No AWS account, no IAM permission policies, no API Gateway, no separate log service, plus a CDN, preview deploys and a single bill. Netlify's 2018 announcement listed exactly that as the product. For an owner without an engineer on staff, that bundle is usually worth more than the markup.
The same function, priced five ways
The workload: one million calls a month, each running 200 milliseconds at 1 GB of memory. Two versions: CPU-bound (all 200 ms is computation) and I/O-bound (20 ms of computation, 180 ms waiting on another service).
Scroll to compare columns and rows when the table extends beyond the box.
| Platform | CPU-bound | I/O-bound | Notes |
|---|---|---|---|
| Raw AWS Lambda, inside the free tier | $0.00 | $0.00 | 200,000 GB-s and 1M requests both fit the monthly free tier |
| Raw AWS Lambda, beyond the free tier | $3.53 | $3.53 | Wall clock, so waiting costs the same as computing |
| Netlify | about 756 credits | about 756 credits | Over Free's 300-credit limit; about 76% of Personal's 1,000; about 25% of Pro's 3,000 |
| Vercel Pro | $8.30 | $1.90 | Both inside Pro's $20 monthly usage credit |
| Cloudflare Workers Paid (not Lambda) | $8.40 | $5.00 | $5 monthly minimum; bills CPU time only |
The arithmetic:
- Lambda: 1,000,000 x 1 GB x 0.2 s = 200,000 GB-seconds x $0.0000166667 = $3.33, plus $0.20 for the requests = $3.53.
- Netlify: 200,000 GB-seconds / 3,600 = 55.6 GB-hours x 10 = 556 credits for compute. If each call arrives as a request to your site, add 1,000,000 / 10,000 x 2 = 200 credits. Total about 756.
- Vercel, CPU-bound: 1,000,000 x 0.2 s = 55.6 CPU-hours x $0.128 = $7.11; 55.6 GB-hours of memory x $0.0106 = $0.59; invocations $0.60. Total $8.30.
- Vercel, I/O-bound: 1,000,000 x 0.02 s = 5.6 CPU-hours x $0.128 = $0.71; memory $0.59 (assuming one request per instance; sharing instances lowers it); invocations $0.60. Total $1.90.
- Cloudflare Workers: CPU-bound uses 200 million CPU milliseconds; 30 million are included, so 170 million x $0.02 per million = $3.40 on top of the $5 minimum. The I/O-bound case uses 20 million, inside the allowance.
What the table leaves out: raw Lambda still needs a front door (an API Gateway or a function URL), logging and data transfer, all billed separately by AWS; the hosted platforms bundle routing and the CDN. And Vercel's Hobby plan would not cover either case (it includes 4 CPU-hours) even if it were allowed for business use, which it is not: "Hobby teams are restricted to non-commercial personal use only."
Cloudflare Workers is in the table as a contrast. It does not run on Lambda; it runs code in V8 isolates inside Cloudflare's own network, and its price list reflects that. The Cloudflare developer platform explainer covers when that model fits.
What it means for a small business
A five-person landscaping company with a quote form
The form posts to one function about 1,500 times a month, 300 milliseconds a time, at Netlify's default 1 GB. That is 1,500 x 0.3 s = 450 GB-seconds, or 0.125 GB-hours, or about 1.25 credits a month. The function is a rounding error.
The thing to watch is elsewhere: each successful production deploy costs 15 credits, so 20 deploys in a month use 300 credits, which is the entire Free plan limit. If your developer pushes small fixes straight to production every day, that habit costs more than every form submission you will get this year. Batch the changes, or use preview deploys (which are free) and promote less often.
Moving this company to raw AWS to save money would be a mistake. The saving is cents, and the cost is someone's afternoon setting up permissions and a gateway.
A 14-person online shop writing product descriptions with an AI model
A function sends each new product to an AI API and waits about six seconds for the answer. 50,000 calls a month at 1 GB:
- Raw Lambda: 50,000 x 6 s x 1 GB = 300,000 GB-seconds x $0.0000166667 = $5.00, plus a cent of requests. Inside the free tier if nothing else is using it.
- Netlify: 300,000 / 3,600 = 83.3 GB-hours x 10 = 833 credits, plus about 10 for requests. Most of the Personal plan's 1,000 credits, gone to waiting.
- Vercel: say 50 ms of real computation per call: 2,500 seconds = 0.69 CPU-hours x $0.128 = $0.09; memory 83.3 GB-hours x $0.0106 = $0.88; invocations $0.03. About $1.00.
This is the case where the meter matters more than the platform. Wall-clock billing (Lambda, Netlify) charges full price for six seconds of waiting; CPU billing (Vercel's Active CPU, Cloudflare Workers) mostly does not. If your functions spend their lives waiting on AI calls, check which meter you are on before the bill tells you.
A three-location restaurant group with a nightly sales report
A scheduled function pulls the day's sales from the point-of-sale system and emails a summary. On Netlify, scheduled functions stop at 30 seconds. If the report takes four minutes on a busy night, it fails quietly on exactly the nights you care about. The fix is a background function (15-minute limit) triggered by the schedule, or splitting the work. This is a limit you inherit from the platform's design, and it is worth knowing before you build on it.
What to do this week
- List every function your site runs, with monthly calls and average duration. Netlify and Vercel both show this in their usage screens. Most owners find two or three they forgot about.
- Check the memory allocation against what each function needs. A function that handles a form does not need 1 GB. On raw Lambda you can lower it as far as 128 MB. On Netlify 1,024 MB is the minimum, so the saving comes from shorter run time instead: return the response before slow follow-up work, or move that work to a background function.
- Mark each function as mostly computing or mostly waiting. If most of them wait on other services, a CPU-metered platform will usually cost less than a wall-clock one.
- If the site is on Vercel Hobby and it earns money, move it to Pro. Vercel's rules count "receiving payment to create, update, or host the site" as commercial use, so a developer building your site on a free Hobby account is outside the terms.
- Count production deploys on Netlify credit plans. At 15 credits each, they add up faster than function calls on a small site.
- Run the free serverless posture audit for timeouts, retries and the other configuration mistakes that cost money.
- Fill in the worksheet in the kit below with your real numbers. It takes about twenty minutes and gives you a monthly figure for each platform.
Copy-paste prompts
Paste these into ChatGPT, Claude or any assistant you already pay for. Attach the export or code they ask for.
Estimate your monthly function cost from a usage export:
I am attaching my hosting platform's function usage export. For each function, list monthly invocations, average duration in milliseconds and allocated memory in MB. Then compute GB-seconds (invocations x duration in seconds x memory in GB) and price each function on these rates, which I checked on 2026-11-01: AWS Lambda $0.20 per million requests plus $0.0000166667 per GB-second (free tier 1M requests and 400,000 GB-seconds a month); Netlify 10 credits per GB-hour of allocated memory; Vercel Pro $0.128 per active CPU-hour, $0.0106 per GB-hour of provisioned memory, $0.60 per million invocations. Show the arithmetic for each line. If a field is missing from the export, say so and do not guess.
Classify each function as computing or waiting:
Here is the source code of my serverless functions. For each one, list every network call it makes (database, AI model, payment provider, email service), estimate what share of its run time is spent waiting on those calls versus computing, and say whether a platform that bills only active CPU time would cost less than one that bills wall-clock time. Say how confident you are in each estimate and what log data would confirm it.
Right-size the memory:
This function runs about [N] times a month, averages [X] ms and is allocated [Y] MB. Here is its code. What is the smallest memory setting that would run it reliably, what would that save per month at $0.0000166667 per GB-second, and what could break if I lower it (timeouts, slower CPU, large libraries)? Tell me how to test the change safely before I make it.
Check your plan against the platform's commercial-use terms:
Here is how my business uses this website: [describe: do you sell, take bookings, run ads, pay a developer]. Here is the hosting platform's fair-use or commercial-use policy text: [paste it]. Tell me whether my use counts as commercial under that exact wording, quote the sentences that decide it, and say what plan the policy requires. If the wording is ambiguous for my case, say so.
Download the kit
The serverless cost worksheet is a plain markdown file you can print or open in any editor. It has an inventory table for your functions, the formulas and rates above (dated, so you know when to re-check them), a worked example to copy, a checklist of the five bills that surprise owners, and the four prompts.
Fact-check notes and sources
- Lambda prices and free tier: $0.20 per million requests, $0.0000166667 per GB-second, one million requests and 400,000 GB-seconds free each month. AWS Lambda pricing
- Lambda memory and CPU: 128 MB to 10,240 MB; one vCPU at 1,769 MB. AWS Lambda memory configuration
- Initialization billing: standardized from August 1, 2025, for on-demand functions packaged as ZIP files. AWS Compute Blog
- AWS scale: Q3 2026 AWS segment sales of $46.0 billion, up 39 percent; operating income $17.8 billion. Amazon third-quarter 2026 results
- Netlify on Lambda, 2018: "deploy serverless AWS Lambda functions on Netlify without configuring API gateways, coordinating deployments, or setting up an AWS account." Netlify blog
- Netlify runtime and limits today: the runtime "must be a valid AWS Lambda runtime for Node.js", the
AWS_LAMBDA_JS_RUNTIMEoverride, 60 s / 30 s / 15 min limits, 1,024 MB default memory with an allowed range of 1,024 to 4,096 MB (credit-based Pro and Enterprise only), billing that "scales linearly with the configured size". Netlify functions configuration - Netlify credit rates: 10 credits per GB-hour of allocated memory, no per-invocation charge, 20 credits per GB of bandwidth, 2 credits per 10,000 web requests, 15 credits per production deploy. How credits work
- Netlify plans: Free with a 300-credit limit, Personal $9 with 1,000 credits, Pro $20 with 3,000 credits. Netlify pricing
- Vercel on Lambda: "Vercel Functions run on AWS Lambda" (July 28, 2025). Vercel engineering blog
- Vercel rates: Active CPU $0.128 per hour and provisioned memory $0.0106 per GB-hour in iad1, $0.60 per million invocations, Hobby allowances, and the CPU-pauses-on-I/O rule. Vercel fluid compute pricing
- Vercel Pro plan: $20 a month with $20 of included usage credit. Vercel pricing
- Vercel Hobby is non-commercial: "Hobby teams are restricted to non-commercial personal use only." Vercel fair use guidelines
- Zapier Code steps run on Lambda: Zapier help center
- Serverless Framework licence: CLI v4 free "except for organizations earning over $2 million annually". Serverless pricing
- SST: open source, deploys into your own AWS account. SST docs
- Customer examples: FINRA, Toyota Connected and Fannie Mae figures, from a paper AWS marks as historical reference. AWS whitepaper case studies
- Cloudflare Workers: $5 monthly minimum, 10 million requests and 30 million CPU milliseconds included, then $0.30 per million requests and $0.02 per million CPU milliseconds. Workers pricing
- My arithmetic: the per-GB-hour comparisons value a credit at the plan's own price ($20 / 3,000 and $9 / 1,000). The worked examples assume 1 GB of memory and, for Vercel, one request per instance. Every price was read on the vendor's page on 2026-10-31 and 2026-11-01; vendors change these, so re-check before you decide.
Related reading
- What hosting a new business site actually costs in 2026: the platform-picking companion to this post.
- Auditing serverless functions for the 25 posture failures that cost you money: the configuration mistakes behind most surprise bills.
- The Cloudflare developer platform, explained: the main non-Lambda model, in depth.
- Going frameworkless on Cloudflare, and why you still reach for Vercel, Netlify and Squarespace: what the bundle saves you, and what it locks in.
- Sending your own email digest from serverless functions: a real small-business function, end to end.
This post is informational, not legal, financial or hosting-consulting advice. Prices were read from each vendor's own pages on the dates given and change often. Mentions of Amazon Web Services, Netlify, Vercel, Zapier, Cloudflare, Serverless Inc. and SST are nominative fair use. No affiliation is implied.
