Monday, November 16, 2026 Edition No. 240
Search
Review Human-led, AI-assisted · Infrastructure · 24 min read

AWS Lambda MicroVMs Pricing, Explained

By Fabio Douek

Human-led, AI-assisted. Research and implementation done with AI tools, led, tested and edited by me. How posts are labeled

Jump to section
Explain (TLDR) like I am...
What is this?

Imagine renting a toy robot that costs a tiny coin every second it is switched on, and four coins a second when it runs really fast. When you go for a snack, you can put it to sleep in a box, and the box costs almost nothing to keep.

Putting it to sleep and waking it up costs about as much as five minutes of play, so it is only worth it if your snack break is longer than that. Most of the money goes on the time the robot is awake and working, not on the box.

AWS publishes five rates for Lambda MicroVMs and two worked examples, but the examples rest on assumptions a buyer should test: the size of each snapshot, how much time runs above the baseline, and the exclusion of data transfer. Neither example is a quote.

The material exposure is compute, nine tenths or more of both bills. Snapshot charges are metered on size used, and the one public bill found reads about four times the memory snapshot per launch. There is no free tier and, as far as the published rate files show, no Savings Plans discount, so budget at list price and verify against Cost Explorer.

The presenting complaint is an opaque bill: five rates, two worked examples, and no way to see which assumption drives which line. Rebuilding both from a single MicroVM makes the diagnosis plain. Compute is nine tenths or more of the cost, and burst seconds are a large share of it.

Suspending is the main treatment, effective for pauses longer than about five minutes and counterproductive below that. Side effects to monitor: idle time before auto-suspend is billed, snapshot sizes are assumed, and data transfer is excluded. Evidence from real bills is still thin.

Pricing pages can feel like a wall of tiny decimals, and it is easy to suspect you have missed the trick. Walking from one MicroVM to a day to a whole team takes the anxiety out of it: each number has a reason, and most of the bill comes from one place.

The tension is in the habits it rewards. Teams that let sandboxes sleep when people step away pay half; teams that keep everything awake out of caution pay double. That is a conversation about trusting the suspend button as much as it is about money.

Think of a MicroVM bill as a metronome: one click a second while the sandbox runs, four times louder when it bursts. Rests are nearly free, but every stop and restart costs a beat, about five minutes of playing time.

So the arrangement matters more than the tempo. A coding sandbox with long rests and short loud passages comes to about twelve dollars a developer a month. A CI job that plays straight through, with one loud minute, comes to about eleven cents a run.

The story AWS tells with its own numbers is $12.41 per developer a month for a coding sandbox and 11 cents per CI job. Rebuilt from one MicroVM, both hold up, and the selling point is clear: warm sessions that sleep cheaply and burst only when they need to.

The positioning has limits. For CI, a Fargate task or EC2 instance sized for the job costs about the same or less. For sandboxes, the cheaper AWS options that reach the peak lose memory when idle. Lead with stateful, isolated sessions, not with the price per vCPU.

GitHub See the source code here: lambda-microvm-pricing

Overview

The AWS Lambda pricing page gives Lambda MicroVMs five rates and two worked examples: sandboxes for a coding assistant at $1,241.22 a month for 100 developers, and CI jobs at $1,124.03 for 10,000 runs. The examples go straight from the rates to monthly totals, so it’s hard to see which assumption drives which line. In my hands-on series I mostly cared whether MicroVMs worked. This post is about what they cost.

I rebuild both examples from a single MicroVM, one step at a time: an hour at the baseline, a burst, a suspend and resume, a developer’s day, then the whole team. A small calculator reproduces every line of both examples to the cent. Then I cover what the examples leave out, check the model against my own bill for the series, and compare both workloads with other AWS services: EC2, Fargate, CodeBuild and Lambda functions.

The short version: compute is almost the whole bill, suspending pays for itself after about five minutes of idle time, and the snapshot charges depend on how big your snapshots actually are, which the examples assume rather than measure.

All prices in this post are AWS list prices as of November 9, 2026, in us-east-1 unless I say otherwise.

The rate card

MicroVMs bill five usage types. These are the names on my Cost Explorer bill, with the us-east-1 Graviton rates as of November 9, 2026:

Usage typePricing pagePrice list (what the bill charges)Charged
Lambda-MicroVM-vCPU-Second-ARM$0.0000276944 per vCPU-secondsameevery second the MicroVM runs
Lambda-MicroVM-Memory-GB-Second-ARM$0.0000036667 per GB-secondsameevery second the MicroVM runs
Lambda-MicroVM-Snapshot-Write-GB$0.0038 per GB$0.0037977138on every suspend
Lambda-MicroVM-Snapshot-Read-GB$0.00155 per GB$0.0015467699on every launch and resume
Lambda-MicroVM-Snapshot-Storage-GB-Hour$0.08 per GB-month$0.0001111111 per GB-hourimages and suspended MicroVMs

A few rules shape everything that follows:

  • Size is set by memory. You pick a baseline memory size and get one vCPU per 2 GB. The default is 2 GB with 1 vCPU, and the largest baseline is 8 GB with 4 vCPU (images and sizing).
  • A MicroVM can burst to 4x its baseline with no action from you. You pay the baseline while it runs and, in the page’s words, “only for the active duration of the additional memory and vCPU consumed – not for the peak capacity”.
  • Compute is billed per second. I found no documented minimum duration.
  • Snapshots are billed on what they use. The price list measures snapshot reads and writes “in GB of memory and disk used by snapshot” and storage “weighted by snapshot memory and disk used”, where Lambda SnapStart in the same file says “assigned to function”. The 2 GB in the examples is an assumption about the workload, not the configured memory.
  • Image storage has a one-week minimum, and data transfer is billed separately at standard AWS rates.
  • No free tier, and no Savings Plans. The free tier on the pricing page covers Event Functions only. The Compute Savings Plans rate file for us-east-1 lists no MicroVM usage type, so as far as I can tell there is no commitment discount today.

The page’s examples use snapshot rates rounded to five decimals; the bill uses the price list’s. The difference is small: Example 1 comes to $1,241.07 at the exact rates instead of $1,241.22. I use the page’s rates below so every number matches AWS’s.

Rates vary by Region. us-east-2 and us-west-2 match us-east-1; both examples cost about 5% more in eu-west-1, 17% more in ap-northeast-1 and 27% more in eu-central-1. The price list also carries x86 rates, 17.9% above Graviton in us-east-1, and the Developer Guide now says x86_64 is supported from base image version 3, but the pricing page only shows Graviton.

Example 1: A coding sandbox, one step at a time

AWS’s scenario: each developer gets an isolated sandbox for AI-assisted coding, with a 2 GB / 1 vCPU baseline that bursts to 8 GB / 4 vCPU to compile and run tests. The workday is 8 hours. The sandbox is active for 2.5 of them, 25% of that at peak, and suspended for the other 5.5, with six suspend/resume cycles. There are 100 developers, 20 workdays a month, and five 2 GB language images.

Step 1: One MicroVM, one hour

Start with one MicroVM at the default size, doing nothing in particular:

per second   1 vCPU x $0.0000276944 + 2 GB x $0.0000036667 = $0.0000350278
per hour     $0.0997 vCPU + $0.0264 memory                  = $0.1261

That’s the floor: about 12.6 cents an hour, 79% of it vCPU, billed for every second the MicroVM is running, whether it’s compiling or waiting for a keystroke. Left running for its full 8-hour lifetime it costs $1.01. Around the clock it would be $3.03 a day, the number quoted in the launch threads, though no MicroVM can run longer than 8 hours.

Step 2: Bursting above the baseline

When the agent compiles or runs tests, the MicroVM scales to 4 vCPU and 8 GB on its own. In fact the guest always sees the peak: in part 1 a default 2 GB MicroVM reported nproc 4 and 8 GB of MemTotal, with no cgroup limits. Build tools that size their worker pools from the CPU count will burst by default. At full size a second costs exactly four times as much, $0.0001401112, or $0.5044 an hour.

In the example, the sandbox is active for 2.5 hours a day (9,000 seconds) and at peak for a quarter of that (2,250 seconds). There are two ways to price it, and they give the same total:

ReadingCalculationCost
AWS’s lines: peak seconds at peak size, baseline seconds at baseline2,250 s × $0.0001401112 + 6,750 s × $0.0000350278$0.3153 + $0.2364 = $0.5517
The billing rule: the floor for all active time, plus the extra 3 vCPU / 6 GB while it’s used9,000 s × $0.0000350278 + 2,250 s × $0.0001050834$0.3153 + $0.2364 = $0.5517

The two readings produce the same two numbers with the labels swapped. That’s a coincidence of the example: 25% of the time at 4x equals 100% at 1x. Don’t read too much into which line is called “peak”.

One assumption to note: the example puts the MicroVM at the full 4x for every peak second. The billing rule charges for the vCPU and memory actually consumed above the baseline, so a burst that only reaches 2 vCPU and 4 GB costs less than the example’s.

Step 3: Suspend and resume

For the other 5.5 hours the developer is reading, in meetings or at lunch. Paying the floor for that time is waste, so the sandbox suspends:

suspend    write 2 GB x $0.0038   = $0.0076   compute stops
suspended  2 GB x $0.08 / 720 h   = $0.00022 per hour
resume     read 2 GB x $0.00155   = $0.0031
one cycle                         = $0.0107

A suspended hour costs about 1/570th of a running one. The cost of suspending is the cycle itself: $0.0107 is what the 2 GB baseline costs in about 305 seconds of running. So the rule of thumb is that suspending pays off when the pause is longer than about five minutes. For shorter pauses, keep it running. For the same reason, in Example 1 the snapshot reads and writes cost 55 times more than the suspended storage: the number of cycles matters far more than the hours spent suspended.

Step 4: One developer’s day

Put it together for one developer:

running at baseline running at peak suspended suspend / resume launch: read the 2 GB image 9:00 10:00 11:00 12:00 13:00 14:00 15:00 16:00 17:00 8-hour cap (suspended time counts) overnight:nothing billed 7 active stretches: 2.5 h, a quarter of it at peak 6 suspended gaps: 5.5 h, 6 suspend/resume cycles
LineCalculationCost
Launchread the 2 GB image: 2 GB × $0.00155$0.0031
ComputeStep 2$0.5517
Suspend/resume6 cycles × $0.0107$0.0642
Suspended storage2 GB × 5.5 h × $0.08 / 720 h$0.0012
One developer-day$0.6202

The same day without suspending, idling at the baseline for the 5.5 hours, costs $1.25. Suspending halves the bill.

The example also has a hard edge that it doesn’t spell out. A MicroVM lives for at most 8 hours, and suspended time counts towards that cap (I measured it in part 1, Test 6). 2.5 active hours plus 5.5 suspended is exactly 8, so the MicroVM reaches its cap at the end of the day. That’s why there’s one launch per developer per day, and why the example bills nothing for the other 16 hours. If a developer needs tomorrow’s sandbox to remember today, that state has to live somewhere else.

Step 5: 100 developers, 20 days

Now multiply: 100 developers × 20 workdays is 2,000 sandbox days.

2,000 x $0.62021                = $1,240.42
5 images x 2 GB x $0.08         =     $0.80
monthly total                   = $1,241.22   ($12.41 per developer)

That matches AWS. Here is the page’s own breakdown, which the calculator reproduces line by line:

Example 1, line by line (python microvm_cost.py scenarios/coding-sandboxes.json)
Compute
  Peak                  4.50M s at 4 vCPU / 8 GB                           $630.50
    vCPU                4.50M s x 4 vCPU                                   $498.50
    memory              4.50M s x 8 GB                                     $132.00
  Baseline              13.50M s at 1 vCPU / 2 GB                          $472.88
    vCPU                13.50M s x 1 vCPU                                  $373.87
    memory              13.50M s x 2 GB                                     $99.00
  Compute total                                                          $1,103.38
Snapshot read/write
  Write on suspend      12,000 cycles x 2 GB                                $91.20
  Read on resume        12,000 cycles x 2 GB                                $37.20
  Read on launch        2,000 launches x 2 GB                                $6.20
  Read/write total                                                         $134.60
Snapshot storage
  Images                5 x 2 GB for a month                                 $0.80
  Suspended MicroVMs    2,000 x 2 GB x 5.5 h / 720 h                         $2.44
  Storage total                                                              $3.24
----------------------------------------------------------------------------------
Monthly total                                                            $1,241.22
Per developer                                                               $12.41

Share: compute 88.9%, snapshot read/write 10.8%, snapshot storage 0.3%

(The page shows the baseline lines as $373.87 + $99.00 = $472.88. That looks like a one-cent slip, but it’s the unrounded sum, $472.8753, rounded.)

Where the money goes:

Example 1 · $1,241.22 a month Storage $3.24 Baseline seconds$472.88 Peak seconds$630.50 Snapshot read/write$134.60 Example 2 · $1,124.03 a month Snapshots $31.16 Baseline seconds$756.60 Peak seconds$336.27
  • Compute is 89% of the bill, and the peak seconds are 57% of compute. How hard the agent pushes the sandbox matters more than how long the developer leaves it.
  • Snapshot reads and writes are 11%, and two thirds of that is writes. Each extra suspend/resume cycle per developer per day adds $21.40 a month across the team.
  • Storage is 0.3%. Keeping 100 sandboxes suspended for 5.5 hours a day costs $2.44 a month.
  • Without suspend, the same team would pay $2,497.48 a month, $24.97 per developer.

Example 2: CI jobs, one at a time

AWS’s second scenario is a multi-tenant platform running untrusted code (dependency installs, build scripts, vulnerability scanners), so every job gets its own MicroVM. Jobs run once and end; nothing suspends. The baseline is 8 GB / 4 vCPU, bursting to 32 GB / 16 vCPU. A job takes 10 minutes, 10% of it at peak, and launches from one 2 GB image. There are 10,000 jobs a month.

Step 1: One ten-minute job

baseline   4 vCPU + 8 GB  = $0.0001401112 per second   ($0.5044 per hour)
           540 s at baseline                            = $0.0757
peak       16 vCPU + 32 GB = $0.0005604448 per second
           60 s at peak                                 = $0.0336
launch     read the 2 GB image                          = $0.0031
one job                                                 = $0.1124

The burst minute is 10% of the job’s time and 31% of its compute. Running the whole job at 16 vCPU / 32 GB would cost $0.3394, three times as much, which is the case for burst billing in one number.

Step 2: 10,000 jobs

LineCalculationCost
Compute, peak600,000 s × 16 vCPU / 32 GB$336.27
Compute, baseline5.4M s × 4 vCPU / 8 GB$756.60
Launch reads10,000 × 2 GB × $0.00155$31.00
Image storage1 × 2 GB × $0.08$0.16
Monthly total$1,124.03 ($0.1124 per job)

Compute is 97% of this bill. With no suspend, there’s no write cost and no suspended storage, and the only snapshot charge is the launch read. That read is priced on the 2 GB image, not the 8 GB of memory, which fits the “used by snapshot” wording in the price list.

What the examples leave out

Both examples are internally consistent, but each leaves out something you will pay for:

WhatWhy it mattersEffect on Example 1
Idle time before auto-suspendThe idle policy’s maxIdleDurationSeconds has a minimum of 60 (IdlePolicy), and the MicroVM is running and billed until it fires. Calling SuspendMicrovm yourself avoids it.+$25.22 a month at 60 s; +$126.10 at 300 s
Real snapshot sizesCharged on memory and disk used, not configured, but the billed size isn’t the memory snapshot either. The one public bill I found shows launches reading up to 2.49 GB for a 0.59 GB memory snapshot, and what was most likely a suspend writing 1.09 GB on a 2 GB MicroVM.Could be lower or higher than the 2 GB assumed
Data transferInternet egress and traffic between MicroVMs and your VPC are billed at standard AWS rates. Neither example includes any.Depends on traffic
Egress infrastructureIf sandboxes reach the internet through your VPC, the NAT gateway, proxy and load balancer are separate bills. My part 2 setup cost about $0.095 an hour before any MicroVM ran.About $68 a month, fixed
Image storageEach image version is billed for at least a week, even if you delete it sooner. An image is built once per Graviton generation, and the same public bill shows about 1.35 GB billed per version for builds of about 0.62 GB each.About $0.04 a week per 2 GB billed
Transitional statesThe docs say running MicroVMs incur compute charges, suspended ones only storage, and terminated ones nothing. They don’t say how PENDING (including the /run hook), SUSPENDING or TERMINATING are billed.Unknown, likely small

The snapshot row is the one I’d check first for your own workload. That public bill is ADR-0032 in cosmipixel/agentic-qa-platform, a 2 GB Chromium runner in us-east-2: its launch reads come out close to the image’s memory snapshot, disk snapshot and 1.69 GB code install added together. So GetMicrovmImageBuild, which reports those three sizes, is a better guide to launch reads than the memory snapshot alone. The image I built in part 1 reported a 534 MiB memory snapshot, a 23.5 MB disk snapshot and a 573 MB code install. What a suspend writes depends on what the workload has touched; it’s one data point so far.

Checking it against my bill

The three posts in my MicroVMs series ran their tests on 2026-11-03 to 2026-11-05. Two days later, Cost Explorer showed all of it (bill.py prints the same table for your account):

Usage typeQuantityCostEffective rate
Lambda-MicroVM-vCPU-Second-ARM43,346.9 vCPU-s$1.20$0.0000276944
Lambda-MicroVM-Snapshot-Read-GB677.3 GB$1.05$0.0015467699
Lambda-MicroVM-Memory-GB-Second-ARM85,410.6 GB-s$0.31$0.0000036667
Lambda-MicroVM-Snapshot-Write-GB61.6 GB$0.23$0.0037977138
Lambda-MicroVM-Snapshot-Storage-GB-Hour1,952.3 GB-h$0.22$0.0001111111
Total$3.01

What it confirms:

  • The five usage types and their rates match the price list exactly. Storage is metered per GB-hour, which is how the examples price suspended time.
  • Memory GB-s divided by vCPU-s is 1.97, close to the 2:1 of the sizes I ran, so there was little CPU-only burst (a burst that uses vCPU and memory in proportion keeps the ratio at 2). There is no separate usage type for burst: it bills as ordinary vCPU-seconds and GB-seconds.
  • Snapshot reads came second, close behind vCPU. My tests launched many short-lived MicroVMs and suspended few, so snapshot reads outweighed writes 11 to 1. Example 1’s suspend-heavy pattern is the opposite.
  • Storage kept billing after the tests ended: 578.7 GB-hours on 2026-11-06, a day with no compute, about 24 GB held all day. That fits the one-week minimum on each image version the series built, or images I hadn’t deleted yet.

What it can’t confirm: Cost Explorer only gives me daily totals (hourly granularity is opt-in on the payer account), so I can’t split the reads per launch and check how many GB a single launch or suspend was billed for.

How it compares

Both examples priced on other AWS services in us-east-1, on Graviton where there’s a choice, using list prices as of November 9, 2026. These are my calculations from AWS’s published rates; the assumptions matter as much as the numbers.

Example 1, per developer per month (20 workdays of 8 hours, 50 active hours, 12.5 of them needing 4 vCPU / 8 GB):

ServiceAssumptionsCost
Lambda MicroVMsAWS Example 1: burst billed while used, suspend keeps memory$12.41
EC2 c8g.xlarge on-demand4 vCPU / 8 GiB (the peak), running 8 hours a day, plus a 20 GB gp3 volume$27.12
Fargate ARM4 vCPU / 8 GB, running 8 hours a day$25.28
EC2 c8g.xlarge spotthe same, at the median us-east-1 spot price on 2026-11-07; can be interrupted$15.79
EC2 t4g.large2 vCPU / 8 GiB burstable, running 8 hours a day, plus 20 GB gp3: the peak memory, half the peak CPU$12.35
EC2 c8g.xlarge, stopped when idlethe peak for the 50 active hours, plus 20 GB gp3; memory and processes lost, boots each session$9.58
Fargate ARM, stopped when idle4 vCPU / 8 GB for the 50 active hours; restarts with no state$7.90
Fargate ARM at the baseline1 vCPU / 2 GB, running 8 hours a day, no burst$6.32

Everything that stays up through the workday and can reach the peak costs more than MicroVMs, from $15.79 on spot to $27.12. The t4g.large costs about the same and keeps its memory, but has half the peak CPU. Everything else under $12.41 either loses the sandbox’s memory and processes while the developer is away or never bursts. If keeping a warm session matters, MicroVMs are the cheapest of these; if a cold start each session is fine, they aren’t.

Lambda functions aren’t in the table because they can’t hold a sandbox: an invocation runs for at most 15 minutes and keeps nothing in memory between invocations. Per GB-second they cost $0.0000133334 on Graviton, 24% less than a MicroVM’s $0.0000175139 at 1 vCPU per 2 GB, and a 2 GB function gets slightly more CPU (about 1.16 vCPU).

Example 2, per job (10 minutes, 1 minute needing 16 vCPU / 32 GB):

ServiceAssumptionsPer job10,000 jobs
Lambda MicroVMsAWS Example 2$0.1124$1,124.03
EC2 c8g.4xlarge on-demand16 vCPU / 32 GiB for the whole job, plus boot time$0.1063$1,063.47
Fargate ARM16 vCPU / 32 GB for the whole job$0.1053$1,053.33
CodeBuild arm1.medium4 vCPU / 8 GiB, no burst$0.0700$700.00
Lambda function, Graviton8 GB (about 4.6 vCPU), no burst, no Docker, 15-minute limit$0.0640$640.01
CodeBuild lambda.arm.8GBCodeBuild on Lambda compute: 8 GB, 4 vCPU, no burst, no Docker, 15-minute limit$0.0480$480.00
Fargate ARM4 vCPU / 8 GB, no burst$0.0263$263.33

For CI, MicroVMs cost about the same as a Fargate task or EC2 instance sized for the peak for the whole ten minutes. Lambda’s MicroVM rates are 3.08 times Fargate ARM’s per vCPU and 3.71 times per GB; burst billing only makes up the difference. Options sized for the baseline are 38% to 77% cheaper than the bursting job, but they run its peak minute at about a quarter of the size. If your jobs don’t need the burst at all, the same job on a MicroVM at the baseline costs $0.0872, and the baseline options are 20% (CodeBuild arm1.medium) to 70% (Fargate) cheaper. The case for MicroVMs here is isolation per job and a start from a snapshot, not price.

Verdict

The MicroVMs pricing model has five rates, but only one dominates both examples: compute. 89% of the coding sandbox bill and 97% of the CI bill is vCPU and memory, and in both the burst seconds are an outsized share of it. Snapshot charges matter only in proportion to how often you suspend and how big your snapshots really are.

What the model rewards:

  • Workloads that idle for long stretches and need their memory back. A suspended sandbox costs 1/570th of a running one, and a full cycle pays for itself after about five minutes. That’s the coding sandbox case, and it’s where MicroVMs beat every other AWS option I priced that keeps memory and can reach the peak.
  • Short, occasional bursts. You pay the 4x only while it’s used, so Example 2’s job costs a third of running it at peak size throughout.

What it punishes:

  • Running all day. At $0.126 an hour for 1 vCPU / 2 GB, a MicroVM that never suspends costs about three times Fargate.
  • Frequent, short suspends. Below about five minutes of idle time, a cycle costs more than staying up, and the auto-suspend timer adds at least 60 billed seconds to each one.
  • Long-lived sessions. The 8-hour cap ends every MicroVM, suspended or not. Example 1 fits a workday into it exactly; anything longer needs its own way to persist state.

Before trusting either example for your own budget, measure two things: how big your suspend snapshots are, and how much of your active time runs above the baseline. Then put them in the calculator, which takes any of the examples’ assumptions as overrides:

python microvm_cost.py scenarios/coding-sandboxes.json --set state_gb=1.1 --set cycles=10 --steps

Comments