The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →SnapStart and GraalVM Native Image shorten Java startup in different ways: SnapStart restores a snapshot of an initialized execution environment, while Native Image compiles the application ahead of time so it can start without JVM boot. Neither guarantees the lowest warm latency or the smallest AWS bill. In an AWS Compute Blog benchmark, Native Image had a lower CPU-bound warm median than SnapStart, while Managed Instances had the lowest median overall. Your result depends on workload, traffic pattern, memory setting, and how much time your function spends waiting on other services.
What changes when you use SnapStart or Native Image?
SnapStart restores an initialized environment
With SnapStart, Lambda initializes a published function version, takes a snapshot of the initialized environment’s memory and disk state, and uses cached copies to resume new execution environments. AWS describes the snapshot as a Firecracker microVM snapshot that is encrypted and cached to optimize retrieval latency. This shifts much of initialization work to version publication; it does not remove all restore, reinitialization, or handler work from a later startup.
As an Amazon Associate I earn from qualifying purchases.
That distinction matters when interpreting a “cold start” result: restore time and any work your application performs after restoration can still contribute to first-request latency. AWS says optimal SnapStart startup can be sub-second, but the result for a particular function depends on its initialization and restore behavior.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitchesNative Image avoids JVM boot
GraalVM Native Image compiles the application into a native executable ahead of time. It can avoid starting a JVM at invocation time, but it also requires a compatible native build and dependencies. Dynamic features such as reflection or class loading can require explicit configuration or changes to the application or build pipeline.
#1 Best Overall
Java 25’s AOT cache is a separate feature
AWS’s Java 25 managed runtime includes an ahead-of-time cache for the Lambda runtime interface client. That cache is not a GraalVM Native Image of your application. AWS ties the cache to the JVM build, warns that runtime updates can invalidate user-deployed caches, recommends container images for those caches, and says the AOT cache cannot be used together with a CDS cache.
What the AWS benchmark measured
The figures below are from an AWS Compute Blog benchmark page accessed October 5, 2026; the page content available for this comparison did not establish its publication date. AWS tested Java 25, Spring Boot 4.0.6, and AWS SDK for Java 2.x, with 240,000 requests at 33 requests per second across three workloads. The benchmark describes ten runs of 2,000 requests. Standard Lambda, SnapStart, and Native Image used 1,024 MB; Lambda Managed Instances used c7i.xlarge. These are results for that test setup, not service-wide guarantees.
Rank #2
Cold-start-related maximums in the CPU-bound PDF workload
| Configuration | Reported maximum latency | How to read it |
|---|---|---|
| Standard Lambda | 13,270 ms | AWS benchmark result for this workload. |
| SnapStart | Under 3 seconds | AWS benchmark result; restore and reinitialization still occur. |
| GraalVM Native Image | Under 2 seconds | AWS benchmark result; Native Image skipped JVM boot. |
| Lambda Managed Instances | 487 ms | AWS identifies this maximum as a slow warm request, not a cold start. |
The 487 ms Managed Instances maximum is therefore not a like-for-like cold-start figure against the other three entries. The benchmark also does not establish that every Native Image function starts faster than every SnapStart function; its figures belong to the tested application and setup.
Warm latency varied by workload
| Workload and metric | Standard Lambda | SnapStart | Native Image | Managed Instances |
|---|---|---|---|---|
| CPU-bound, p50 | 139 ms | 127 ms | 107 ms | 97 ms |
| I/O plus computation, p50 | 228 ms | Not stated in the AWS benchmark | Not stated in the AWS benchmark | 184 ms |
| I/O plus computation, p99 | 3,201 ms | Not stated in the AWS benchmark | Not stated in the AWS benchmark | 1,883 ms |
| I/O-bound, p50 | 93 ms | Not stated in the AWS benchmark | Not stated in the AWS benchmark | 76 ms |
For the CPU-bound test, Native Image’s 107 ms median was lower than SnapStart’s 127 ms, but Managed Instances led at 97 ms. AWS attributes part of the Managed Instances advantage to a persistent JVM having time to reach C2 JIT optimizations. C1 is tuned for faster startup; C2 spends more time and memory optimizing performance. On the I/O-heavy tests, time waiting on services such as DynamoDB, SQS, and SNS limits how much CPU optimization can improve end-to-end latency. AWS reported Managed Instances’ p50 advantage over Standard Lambda as 30% for CPU-bound, 19% for mixed I/O and computation, and 18% for I/O-bound workloads in this benchmark.
Why warm latency is not the same as cold-start latency
A first request to a new execution environment and a request served by an already-warm environment are different measurements. SnapStart targets the initialization and restoration cost of new environments. A persistent JVM can also optimize hot code over time, which may benefit steady-state CPU-bound work. Native Image avoids JVM startup, but its warm performance still depends on the compiled application and workload; the benchmark’s CPU-bound median shows it should not be assumed to lose once warm.
Java 25’s default tiered JVM behavior for SnapStart and provisioned concurrency allows JIT work to happen outside the invoke path; priming can exercise code paths before a snapshot. That can affect the balance between startup preparation and later execution. It does not make a CPU-bound benchmark a reliable predictor for a function whose time is dominated by downstream I/O.
Rank #4
What happens to the AWS bill?
AWS says Java managed runtimes have no additional SnapStart charge. That does not make a SnapStart function free: ordinary request, duration, and configured-memory charges still apply. Lambda duration billing includes initialization code outside the handler and runtime-hook duration where applicable, so moving initialization to version publication does not by itself prove that the total bill will fall.
Free tools Windows power users keep installed
One-click scans. No signup required.
Nor do the benchmark’s lower startup figures establish that Native Image costs less. To compare spend, use your own invocation count and burst pattern, billed duration distribution, memory setting, architecture, applicable rates, and any initialization or runtime-hook work. A lower memory footprint or shorter startup is not enough to calculate savings without those inputs.
Best Value
Inputs to compare for your function
- Traffic: invocation volume, bursts, scale-out frequency, and how often environments are reused.
- Latency: first-invoke and restore distributions as well as warm p50, p95, and p99; separate CPU time from downstream wait time.
- Billing: configured memory, billed duration, initialization and hook work, architecture, and the rate card that applies to your deployment.
- Operations: deployment and build effort, dependency compatibility, snapshot-safe state, and the way connections are refreshed or re-established.
Choose based on the constraint you need to solve
Choose SnapStart when initialization is the bottleneck
SnapStart is worth evaluating when Java initialization is a major part of first-request or scale-out latency and your function can safely resume from a snapshot. AWS recommends loading startup-heavy dependencies and resources during initialization. It also notes that infrequently invoked functions may not see the same benefits as functions invoked at scale.
Snapshot safety is an application concern. State that must be unique per execution environment, fresh randomness or entropy, and network connections that may no longer be valid after restoration need appropriate handling. Generate or refresh values after restore where necessary, and validate or recreate connections rather than assuming their state remains usable.
Choose Native Image when a native build fits your application
Native Image is a candidate when avoiding JVM boot is valuable and your dependencies and build pipeline work reliably with ahead-of-time compilation. Check reflection, dynamic loading, configuration, and reproducibility as part of the decision. Do not choose it on the assumption that lower startup automatically means lower warm latency or a smaller bill; compare those outcomes with representative traffic.
Consider Managed Instances or provisioned concurrency for different needs
The AWS benchmark’s Managed Instances results illustrate the potential steady-state advantage of a persistent JVM, especially for CPU-bound work; that option uses a different execution model and the benchmark used c7i.xlarge instances. For strict cold-start targets, provisioned concurrency is another AWS option to evaluate. Current SnapStart documentation says SnapStart does not support provisioned concurrency, so these are not features to combine on the same configuration.
How to make a reliable comparison
- Define the latency target. Decide whether the requirement concerns first invocation, scale-out, warm p50, or tail latency; do not substitute one metric for another.
- Run the same representative workload. Keep the application behavior, dependency calls, request mix, memory setting, and region consistent across candidates.
- Separate startup from steady state. Collect initialization or restore measurements and invocation latency distributions, distinguishing first invokes in new environments from warmed requests.
- Test traffic shape. Include realistic bursts and quiet periods, since environment reuse and JVM warm-up opportunity change with traffic.
- Calculate cost from observed usage. Apply the relevant rates to measured billed duration, memory, requests, architecture, and initialization or hook work rather than inferring cost from a startup benchmark.
- Validate correctness and deployment. Check snapshot-sensitive state for SnapStart; test native compatibility and build reproducibility for Native Image.
Use AWS’s Lambda documentation for current runtime availability and feature limitations before choosing a deployment. The documentation lists limitations for SnapStart, including no provisioned concurrency, EFS, S3 Files, or ephemeral storage above 512 MB; supported runtimes and regional availability can change, so verify the current documentation for your target region.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
