“Serverless GPU” now means two very different bills. RunPod Serverless charges for the seconds a worker actually runs. AWS’s new Lambda GPU functions, launched Nov 18, 2026, charge for EC2 instance time your capacity sits provisioned — plus a 9.75% management fee and $0.20 per million requests — with no per-request duration charge at all. And the third option is the oldest one: rent the GPU by the hour and pay for its idle time yourself. This guide prices all three shapes from the providers’ own published rates, checked Nov 19, 2026, works the cost of a million requests at two request lengths, and finds the utilisation line where the always-on instance starts winning.
The short answer
If your traffic is spiky, low or unpredictable, rent seconds, not hours. RunPod Serverless Flex is the purer serverless of the two: a worker that has scaled down bills nothing, and you pay only for start, execution and a short idle tail. On the two card classes both providers offer, its busy-hour rate is also the lower one — $0.75/hr for the L4 class against an effective $0.88/hr for AWS’s L4 instance (g6.xlarge), and $1.89/hr for the L40S class against an effective $2.04/hr for AWS’s L40S instance (g6e.xlarge), each AWS figure being the EC2 On-Demand rate plus the 9.75% fee, checked Nov 21, 2026. If your workload lives inside AWS — triggered by S3, SQS, EventBridge or any of Lambda’s 200-plus event sources, billed on the same account, with Savings Plans already in place — Lambda GPU functions are the integration play, and their economics hinge on one feature RunPod does not have: an execution environment can serve up to 48 concurrent requests on one GPU. Serve requests one at a time and AWS is the most expensive route per request in this guide; pack them concurrently and the same instance-hour divides across all of them. If your traffic is steady, skip both. The cheapest verified L40S instance on our board, RunPod Community at $0.79/hr (checked Nov 19, 2026), beats RunPod Serverless once the GPU is busy more than about 41.8% of the month, and beats AWS’s provisioned g6e once capacity would sit provisioned more than about 38.7% of the time. Past those lines you are paying serverless prices for an always-on workload.
TL;DR — the three routes side by side (rates checked Nov 19, 2026)
| Route | How you pay | Best for | The catch |
|---|
| AWS Lambda GPU functions (Lambda Managed Instances on EC2 G-series) | EC2 instance time while capacity is provisioned, + 9.75% management fee on the On-Demand price, + $0.20 per million requests. No duration charge per request. | Event-driven inference already inside AWS; spiky traffic if you switch scale-to-zero on; models that pack many concurrent requests onto one GPU. | It is not pay-per-request compute. The default keeps a warm baseline (minimum 3 execution environments), scale-to-zero is opt-in, and new accounts may start with a G-series quota of 0. |
| RunPod Serverless (Flex workers) | Per second a worker runs, from worker start until it fully stops, rounded up to the nearest second. L40S class $1.89/hr of busy time; L4 class $0.75/hr. | Bursty or unpredictable inference with no AWS tie-in; the widest GPU menu of the two serverless routes, up to B300. | Cold start and a 5-second idle tail after each burst are billed time. Per busy hour it costs more than the same card rented as an instance. |
| Always-on instance (a rented GPU, e.g. a RunPod Pod) | Flat per-hour rate, 24/7, idle included. Cheapest verified L40S on our board: $0.79/hr (RunPod Community), $576.70 for a 730-hour month. | Steady traffic, latency-sensitive serving, anything busy more than about two-fifths of the day on an L40S. | You pay for every idle hour, and scaling, patching and availability are your job. |
The headline comparison, on the L40S class at 2 seconds per request, sequential serving: a million requests cost $1,050.00 on RunPod Serverless and $1,134.89 on AWS Lambda GPU (g6e.xlarge) — while a RunPod Community L40S instance costs $576.70 for the whole month whether it serves one request or millions, up to its throughput. Serverless wins on volume you do not have; the instance wins on volume you do. The break-even maths is below, with every assumption stated.
Shape one: AWS Lambda GPU — instance time plus 9.75%
AWS announced GPU support for Lambda Event Functions on Nov 18, 2026: functions run as container images on Lambda Managed Instances built from EC2 G-series hardware, and AWS handles drivers, CUDA versions, provisioning and routing. The launch families are G4dn (T4), G5 (A10G), G6 and Gr6 (L4), G6f and Gr6f (fractional L4) and G6e (L40S), with 3 to 48 GB of accelerator memory per function — AWS positions it for inference and custom models, not training or large foundation models. The pricing, from AWS’s own Lambda pricing page, read Nov 19, 2026, has exactly three components: EC2 instance charges for the instances Lambda provisions in your capacity provider, at standard EC2 pricing — Savings Plans and Reserved Instances apply to this part. A compute management fee of 9.75% for GPU G-series instance types (15% for CPU types) — read the pricing page’s own worked example carefully: the fee is calculated on the EC2 On-Demand price, even when a Savings Plan has discounted the instance charge itself; the discount shrinks your instance line, it does not shrink the fee. And request charges of $0.20 per million requests — and that is all: the pricing page states plainly that Managed Instances functions do not pay separately for the execution duration of each request. So an AWS GPU function is not billed like a Lambda function, and it is not billed like RunPod Serverless. You pay for provisioned instance time — the hours your capacity exists — at the EC2 rate plus 9.75%, plus twenty cents per million requests. What a request costs you is therefore decided entirely by how much provisioned time it consumes and how many requests share that time. The EC2 rates below are AWS’s own published On-Demand prices for US East (N. Virginia), Linux, from the AWS Price List file published Nov 18, 2026 and read Nov 19, 2026:
| Instance (GPU) | EC2 On-Demand | With the 9.75% fee | Kept warm 24/7 (730 hrs) |
|---|
| g6.xlarge — 1 × L4, 24GB | $0.8048/hr | $0.88/hr | $644.79/mo |
| g5.xlarge — 1 × A10G, 24GB | $1.006/hr | $1.10/hr | $805.98/mo |
| g6e.xlarge — 1 × L40S, 48GB | $1.861/hr | $2.04/hr | $1,490.99/mo |
Effective hourly figures are the EC2 rate × 1.0975, computed exactly ($0.8833, $1.1041 and $2.0424) and rounded for display; the monthly column is the exact figure × 730 hours. The request fee is on top and is negligible at these volumes: $0.20 per million requests. AWS bills EC2 instance time per second with a 60-second minimum, per its On-Demand pricing page. Regions other than US East (N. Virginia) price differently; this guide uses the one region throughout so the three routes stay comparable.
Shape two: RunPod Serverless — per second a worker runs
RunPod Serverless turns a container into an autoscaling endpoint. Its pricing documentation, read Nov 19, 2026, is unusually explicit about the meter: you are billed from when a worker starts until it fully stops, rounded up to the nearest second, across three phases — cold start (worker start until your handler is ready, mostly model loading; pulling the container image and downloading cached models normally happen while scaled down and are not billed), execution time, and an idle timeout after the last job (default 5 seconds) during which the worker waits for more work. A worker that has scaled down is not billed. Two worker types sit on that meter: Flex workers start on demand and scale to zero when there are no requests, at the standard per-second rate — this is the serverless default and the only publicly priced tier. Active workers run 24/7, which removes cold starts — but RunPod publishes no rate for them; its documentation says only that discounts are “available through sales inquiry.” Any comparison you read that prints an Active-worker price is quoting a negotiated or stale figure, not a list price; this guide prices Flex only. The Flex ladder, from RunPod’s pricing page read Nov 19, 2026 (rates are per hour of worker run time; billing is per second):
| Worker class | VRAM | Flex rate |
|---|
| 16GB class (A4000, A4500, RTX 4000, RTX 2000) | 16GB | $0.58/hr |
| L4 class (L4, A5000, RTX 3090, MIG 24GB) | 24GB | $0.75/hr |
| RTX 4090 | 24GB | $1.34/hr |
| L40S class (L40, L40S, RTX 6000 Ada, MIG 48GB) | 48GB | $1.89/hr |
| A100 | 80GB | $2.99/hr |
| H100 | 80GB | $5.89/hr |
| H200 | 141GB | $6.99/hr |
| B200 | 180GB | $10.79/hr |
| B300 | 288GB | $11.99/hr |
One caution from our own reading today: RunPod’s comparison article elsewhere on its site quotes lower Serverless figures (an H100 worker at $3.35/hr, for example) and warns in its own text that those rates are “published snapshots rather than catalog-refreshed figures.” The pricing page above is the catalogue of record and the source for every RunPod number in this guide. On cold starts, RunPod claims sub-200ms starts on FlashBoot-optimised workers and “low single digit seconds” on standard container workers — the publisher’s figures, from its own comparison page, not independently measured; a large model loading into GPU memory is the real-world cold start, and RunPod bills you for it.
Worked examples: what a million requests cost — L40S class, the class all three routes offer
Shape three is the baseline both serverless shapes have to beat: a GPU you simply rent. From our board snapshot, checked Nov 19, 2026, the L40S — the card class all three routes can serve — costs $0.79/hr at RunPod Community and $1.09/hr at RunPod Secure, per-GPU on-demand, billed per second while the pod runs. A Community L40S kept for a 730-hour month costs $576.70; a Secure one, $795.70. No request fees, no management percentage, no per-second worker meter — and no autoscaling, no managed drivers, and a bill that runs at full rate at 4 a.m. when nobody is calling. Every other provider on the board prices the same shape; the L40S also lists at Nebius $1.55/hr (a from-price, excl. VAT), CoreWeave $2.25/hr and Verda $2.08/hr in the same snapshot, which is why this guide uses the cheapest verified row as the baseline: it is the bar serverless has to clear, not the average. Assumptions, stated once and used throughout: requests are served sequentially, one at a time per GPU (concurrency 1), each taking exactly 2 seconds or exactly 10 seconds of GPU time. A million sequential requests at 2 seconds each consume 555.6 GPU-hours; at 10 seconds, 2,777.8 GPU-hours. RunPod Serverless is charged for execution time only in the main tables — no cold starts, and requests are assumed to arrive back-to-back so the 5-second idle tail is paid once per burst, not per request; the worst case, where every request sits alone and pays the tail, is costed separately below. AWS is charged for exactly the instance-hours the sequential work consumes, as if capacity provisioned and released perfectly with scale-to-zero on, plus the $0.20 request fee; real deployments also pay a termination tail of a few minutes per scale-in, which this model excludes and the watch-outs cover. The always-on instance is charged its flat monthly rate — at a volume of exactly one million requests in the month, the whole month’s rent is the cost of those million requests. All figures are arithmetic on the verified rates above, computed by script.
| Route | Rate used | 1M requests × 2s | 1M requests × 10s |
|---|
| RunPod Serverless (Flex, L40S class) | $1.89/busy hr | $1,050.00 | $5,250.00 |
| AWS Lambda GPU (g6e.xlarge, fee included) | $2.0424/provisioned hr + $0.20 | $1,134.89 | $5,673.67 |
| Always-on instance (RunPod Community L40S pod) | $0.79/hr flat | $576.70 for the month | $576.70 for the month |
The instance row is the whole month’s rent: the same at either request length, and the same for 10M requests if they fit the month’s throughput.
L4 class — the small-model tier
| Route | Rate used | 1M requests × 2s | 1M requests × 10s |
|---|
| RunPod Serverless (Flex, L4 class) | $0.75/busy hr | $416.67 | $2,083.33 |
| AWS Lambda GPU (g6.xlarge, fee included) | $0.8833/provisioned hr + $0.20 | $490.90 | $2,453.72 |
Two honest qualifiers. First, the idle tail: if your traffic is so sparse that every request arrives alone, each RunPod request also pays the worker’s 5-second idle timeout. In that worst case the L40S figures become $3,675.00 (2s requests) and $7,875.00 (10s), and the L4 figures $1,458.33 and $3,125.00 — sparse traffic is where the idle-timeout setting earns its keep, and lengthening it to dodge cold starts quietly converts a serverless endpoint into a part-time instance. Second, concurrency: the sequential model is the worst case for AWS and the natural case for a single-stream worker. An AWS execution environment can serve up to 48 concurrent requests; under the stated assumption of perfect packing — every instance-hour fully shared — a million 2-second requests on a g6e would cost $23.84 at concurrency 48 and $142.04 at concurrency 8. Treat those as the floor the arithmetic allows, not a forecast: real packing is set by GPU memory and how parallel your model actually runs, and AWS scales on CPU utilisation and concurrency saturation signals, not on your hopes.
The break-even lines
Serverless and instance pricing cross at a utilisation, and on the L40S class the lines are close together:
| Comparison | The instance wins once the GPU is busy… |
|---|
| RunPod Community L40S pod ($0.79/hr flat) vs RunPod Serverless L40S class ($1.89/busy hr) | 41.8% of the month — about 305 busy hours |
| RunPod Secure L40S pod ($1.09/hr flat) vs RunPod Serverless L40S class ($1.89/busy hr) | 57.7% of the month — about 421 busy hours |
| RunPod Community L40S pod ($0.79/hr flat) vs AWS Lambda GPU g6e ($2.0424/provisioned hr) | 38.7% of provisioned time |
In request volume, at the Community pod’s $576.70 month: RunPod Serverless on the L40S class matches it at about 549,000 requests a month if each request takes 2 seconds, and at about 110,000 requests a month at 10 seconds each. Below those volumes, per-second billing is cheaper than the rent. Above them, you are paying a premium for flexibility you no longer use. The same shape of line exists on every card class — divide the flat hourly rate by the serverless hourly rate and you have the utilisation where the instance takes over.
Cold starts and warm floors — the part the pricing pages put elsewhere
| Route | The detail |
|---|
| AWS | Lambda Managed Instances does not scale like classic Lambda. AWS’s scaling documentation, read Nov 19, 2026, says scaling is asynchronous, driven by CPU utilisation and multi-concurrency saturation, and that traffic more than doubling within five minutes can throttle while capacity catches up. The default minimum is 3 execution environments across Availability Zones — a warm floor you pay for in provisioned instance time (environments pack onto instances, so the floor is not automatically three whole instances, but it is not zero either). Scale-to-zero exists but is a setting, not the default: set the minimum to 0 with a maximum above 0, and an idle function’s environments stop and its instances terminate, with charges running until termination completes, usually within minutes. The first invocation after that is throttled with an HTTP 429 while an environment starts — “typically a few minutes,” in AWS’s words, and longer for functions with long initialisation, which a GPU model load is. AWS’s own recommendation is to keep a minimum of at least 1 environment for latency-sensitive work, and 3 for AZ redundancy. |
| RunPod | The cold start is inside the bill by design: the meter starts when the worker starts, and the start phase — mostly your model loading into GPU memory — is charged at the same per-second rate. FlashBoot and model caching are RunPod’s mitigations, and its sub-200ms FlashBoot figure is the publisher’s claim for optimised workers. The 5-second default idle timeout is the other dial: long enough to absorb a burst, short enough that sparse traffic pays it constantly. There is no warm floor on Flex unless you buy one — Active workers are exactly that, at a price RunPod does not publish. |
| The instance | No cold start, no throttle window, no scaling signal — the GPU is simply there. That is what the flat rate buys, and for latency-sensitive steady work it is often the real reason to pay it, ahead of the break-even arithmetic. |
Watch-outs before you commit
| Watch-out | The detail |
|---|
| New AWS accounts may not be able to run a GPU function at all on day one | AWS’s launch post warns that new accounts may start with a G-series quota of 0 — the “Running On-Demand G and VT instances” quota — and must request an increase before anything runs. Budget the request into your launch plan; it is a limit increase, not an instant toggle. |
| The 9.75% fee is charged on the On-Demand price, not on what you actually pay for the instance | AWS’s own pricing example computes the management fee from the undiscounted On-Demand rate while the instance line enjoys a Savings Plan discount. Commitments shrink one line of the bill and leave the other untouched. |
| “Serverless” at AWS does not mean the meter stops at zero by default | With the default minimum of 3 execution environments, an idle GPU function still holds provisioned capacity. Scale-to-zero must be switched on, and switching it on buys the 429-and-wait restart described above. |
| RunPod bills the cold start and the tail | Worker start until handler-ready is charged, and so is the idle timeout after every burst. A 30-second job behind a 90-second model load is a 120-second bill, plus the tail. The execution timeout setting is the guard against a runaway job billing unattended — set it deliberately. |
| There is no published Active-worker price | RunPod’s docs route Active discounts through sales. If your design needs an always-warm RunPod worker, its true comparison is the pod price — $0.79/hr Community for an L40S — not a serverless rate. |
| Storage rides along on both | RunPod charges container disk at about $0.10/GB/month and network volumes at $0.07/GB/month under 1TB (its docs, read Nov 19, 2026). AWS functions get up to 32GB of ephemeral storage in the launch configuration; anything persistent lives in S3 or EBS at their own rates, which this guide does not price. |
| Data transfer is the quiet line | AWS gives 100GB of data transfer out to the internet free per month across services (its EC2 pricing page, read Nov 19, 2026); beyond that, per-GB rates apply. Neither provider’s per-GB transfer rates are in any figure in this guide — check them before a media-heavy launch rather than assuming either way. |
| Regional prices move the AWS column | Every AWS figure here is US East (N. Virginia) On-Demand. G-series capacity and price vary by region, and Lambda picks among the instance types you allow — allow several, as AWS’s own walkthrough does, or a capacity crunch in one family becomes your outage. |
Who should pick which
| Route | When it wins |
|---|
| RunPod Serverless | Pick RunPod Serverless if your inference is bursty, experimental or low-volume, you want the widest GPU menu of the two serverless routes (the only one that reaches H100, H200 and B300), and you can tolerate a billed cold start. Below roughly 549,000 two-second requests a month on an L40S class workload, it beats the cheapest instance rent; below 41.8% utilisation it beats it at any request length. |
| AWS Lambda GPU functions | Pick AWS Lambda GPU functions if the workload is born inside AWS — event sources, VPC, IAM and billing already there — and especially if your serving stack packs concurrent requests onto one GPU, because concurrency is the lever that turns AWS’s provisioned-time pricing from the most expensive column into the cheapest. Switch scale-to-zero on for anything latency-tolerant, and file the G-series quota increase before launch day. |
| The always-on instance | Pick the always-on instance if traffic is steady past the break-even lines, if cold starts and throttle windows are unacceptable, or if you simply want the serving stack you already know. On the L40S, $576.70 a month at RunPod Community is the number both serverless routes have to beat, and at real volume neither does. |
How we check
AWS pricing structure — the three components, the 9.75% GPU management fee, the $0.20 per million requests, the absence of a per-request duration charge, and the fee being computed on the On-Demand price in AWS’s worked example — is from the AWS Lambda pricing page, read first-hand Nov 19, 2026. EC2 On-Demand rates (g6.xlarge $0.8048/hr, g5.xlarge $1.006/hr, g6e.xlarge $1.861/hr, US East (N. Virginia), Linux) are from AWS’s Price List offer file for Amazon EC2, version published Nov 18, 2026, extracted and cross-checked against the file’s own price descriptions on Nov 19, 2026; EC2 per-second billing with a 60-second minimum and the 100GB free data-transfer allowance are from AWS’s EC2 On-Demand pricing page, read the same day. Scaling behaviour — asynchronous scaling, the default minimum of 3 execution environments, scale-to-zero as an opt-in setting, 429 throttling on restart from zero, “typically a few minutes” to first environment, and charges continuing until instance termination completes — is from AWS’s Lambda Managed Instances scaling documentation, read Nov 19, 2026. Launch scope (families, 3–48GB accelerator memory, up to 48 concurrent requests per environment, quota warning) is from AWS’s Nov 18, 2026 announcement as reported in our story of the same day. RunPod Serverless mechanics — billing from worker start to full stop rounded up to the nearest second, the three billed phases, the 5-second default idle timeout, Flex versus Active, and storage rates — are from RunPod’s Serverless pricing documentation, read Nov 19, 2026; the Flex rate ladder is from RunPod’s pricing page, read the same day. Instance prices are GPUJournal’s Nov 19, 2026 board snapshot: RunPod Community L40S $0.79/hr, RunPod Secure L40S $1.09/hr, Nebius L40S $1.55/hr (from-price, excl. VAT), CoreWeave L40S $2.25/hr, Verda L40S $2.08/hr. Every total, per-million figure and break-even in this guide is arithmetic on those inputs, computed by script; the worked-example assumptions (sequential serving, stated request durations, perfect-packing concurrency labelled as a floor) are stated where the figures appear. What is deliberately not claimed: no latency, throughput or tokens-per-dollar figure appears here as our finding. RunPod’s sub-200ms FlashBoot figure is printed as the publisher’s claim. No Active-worker rate is printed, because RunPod publishes none. No AWS figure uses a region other than US East (N. Virginia), a Savings Plan discount, or a fractional-GPU (G6f) configuration. The concurrency figures are arithmetic under a stated perfect-packing assumption, not measurements. Egress beyond AWS’s free 100GB is flagged, not priced.