AWS Lambda Customer-Managed Runtimes: An Ownership Guide

AWS Lambda customer-managed runtimes let a platform team publish a shared runtime independently of the function code that uses it. Application teams keep deploying zip archives, while the runtime publisher owns the image, patches, compatibility, and update rollout. AWS announced the feature on 18 November 2026. It applies to Lambda Event Functions; the official overview excludes Lambda Web Functions.
For a team maintaining shared certificates, monitoring extensions, or a language stack across many functions, this can remove repeated deployment work. It also creates an operational dependency: one runtime release can affect applications owned by several teams. The decision deserves the same care as choosing a shared production platform.
This guide was checked against AWS documentation on 20 November 2026. It explains how to decide whether to adopt the feature, establish ownership, and build a rollout process that can be observed and reversed. Code examples illustrate the documented resource model; adapt and validate them in your own account. We have not run these examples against a live AWS deployment for this article.
Start With the Runtime Problem You Actually Have
Identify the Repeated Work
List the changes your teams repeatedly make to function environments. A security agent update might require touching dozens of deployment repositories. Certificate changes may need the same release in several accounts. A custom language runtime may be bundled into each application's package even though the application teams do not maintain it.
Count the coordination work as well as the builds. Who discovers a patch, who checks compatibility, and how many teams must deploy before the change is complete? Those answers provide a better adoption case than the number of functions alone. Ten independently operated functions can be harder to update consistently than a hundred functions in one well-maintained release pipeline.
Keep a Managed Runtime When It Fits
The AWS launch article says Lambda-managed runtimes remain appropriate for many customers. If the supported language runtime meets your needs and shared components are already easy to update, keeping that arrangement avoids taking on a runtime publishing service.
Write the decision as a specific problem statement. For example: a shared extension needs coordinated security updates, and application deployments currently delay those updates. That gives the project a measurable purpose. A general desire for more control leaves the platform team responsible for new work without a clear reason to own it.
Compare the Deployment Models Before Moving Anything
Separate Application Dependencies From Platform Components
The customer-managed model fits components whose lifecycle is shared across applications. Application-specific libraries may still belong with the function's code. Putting every dependency into a central runtime can turn an ordinary application change into a platform release and make unrelated teams depend on one schedule.
Create a boundary document before assembling the image. Name which libraries and extensions the publisher supports, what compatibility it promises, and what consumers must package themselves. Include native dependencies, certificate handling, handler loading, and logging behavior. A short written contract is easier to test than an image whose contents have accumulated over several experiments.
Make the Comparison Against Your Existing Process
| Model | Useful when | Work your team still owns |
|---|---|---|
| Lambda-managed runtime | Supported language and platform defaults meet the application need | Application code, dependencies, and the team's update policy |
| Function layers | Selected shared files can follow function deployment lifecycles | Layer compatibility and adoption by each consumer |
| Function container images | Each application benefits from owning its full image | Building, patching, testing, and deploying those images |
| Customer-managed runtime | Shared environment changes need a separate publisher lifecycle | Runtime image security, compatibility, rollout, and consumer support |
This is a decision table, not a ranking. Compare a representative change in each model. If your current container pipeline already rebuilds and safely deploys the estate, estimate what a separate runtime lifecycle would simplify before adding another production resource family.
Assign the Publisher Role Before Building the Image
Someone Must Own Every Component
AWS's deployment guidance assigns testing and security updates to the publisher. Build an ownership list covering the OS libraries, language runtime, runtime interface client, extensions, and included shared packages. For each component, record how advisories arrive and how support deadlines are tracked.
An updated upstream base image is an input to that process. Your released runtime remains unchanged until you rebuild and publish an update. Put base-image changes into the same tracked intake as language and extension updates so the team can see when a new dependency is available but not yet deployed.
Give Consumers a Support Contract
The consumer needs a contact, a release history, supported architectures, and an explanation of which alias to choose. Agree on how urgent patches are announced and what happens when a function breaks during a runtime change. Include escalation outside the platform team's normal working hours if the functions support critical workloads.
Keep that contract short enough to read during an incident. A consumer should be able to answer who can pause the rollout and who can restore the previous runtime. If those decisions require finding the engineer who created the first image, the publishing process is not ready for broad adoption.
Understand Runtime, Version, and Alias
Keep Identity Separate From Contents
AWS's runtime creation documentation describes the runtime as a parent resource, with a name, ARN, description, license information, and access policy. Versions define image-backed contents; aliases provide a name that functions can reference. A newly created runtime needs a version and alias before ordinary consumers can use it.
Use a name that reflects a compatibility boundary, such as a language major version and your organization's runtime family. Avoid a name that promises universal compatibility. When a future language major version changes behavior, a separate runtime family can make the migration explicit instead of surprising every consumer of an old name.
Use Aliases to Express the Release Process
A practical starting arrangement is dev, test, and prod, with a documented owner for each promotion. Another arrangement can separate language minor versions when consumers need that contract. The alias should tell a developer what updates they are agreeing to receive.
For example, development and test can point at a candidate while production stays on the previous release:
runtime: company-python
dev -> candidate-20261120
test -> candidate-20261120
prod -> stable-previous
This diagram illustrates a release arrangement. The names are examples, not reserved AWS names. Keep the mapping in the deployment record so the next operator can tell which release each cohort is intended to run.
Build a Runtime Image With a Defined Boundary
Follow the Runtime Filesystem Contract
The runtime image documentation distinguishes runtime files from function code and layers. Function code mounts at /var/task, and layers use /opt. AWS recommends runtime locations for publisher-owned code and has specific requirements for paths, bootstrap behavior, and image compatibility.
Follow that document when constructing the image. A container that works as an ordinary function container is not sufficient evidence that it meets every customer-managed runtime requirement. Keep your Dockerfile, build inputs, and compatibility checks together, and review the runtime-specific labels and architecture requirements before publication.
Keep Secrets Out and Dependencies Reviewable
Include public trust material and approved software where appropriate, while obtaining credentials through the application's normal secret-management path. A shared runtime image should not become a distribution mechanism for passwords or tokens. Consumers can read runtime contents, so review what the image contains before sharing it.
Produce a dependency inventory for each build and retain the resolved base digest. A release reviewer should be able to identify which component changed without unpacking two images manually. If an upstream update unexpectedly changes the image size or adds a package, investigate before promoting it to a widely used alias.
Create a Candidate Without Touching Production
Use the Documented CLI Resource Family
AWS documents runtime publishing commands under aws lambda-core, while function operations use aws lambda. Before scripting the workflow, use a current AWS CLI that exposes the commands and confirm their help in your environment. An older CLI failing to recognize a command does not mean a runtime resource has been created or changed.
The following examples assume an authorized development account, an existing compatible runtime image in ECR, and permissions already configured. Replace the image, names, account, and Region with your own verified values. The sample license string is a placeholder that must describe your actual components.
aws lambda-core create-runtime \
--name company-python \
--description "Company Python runtime; owner: platform team" \
--license-info "See the runtime component license register"
aws lambda-core create-runtime-version \
--runtime-name company-python \
--name candidate-20261120 \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/company-runtime:candidate-20261120
Verify the Candidate Before Adding Consumers
Capture the returned resource identifiers and resolved image information. Check that the intended Region and account match the change request. Naming a production-looking alias in a development account is an easy mistake to overlook when copying terminal commands.
Create only a development alias at this stage, then inspect it through the documented console or API. Use a release record to link the runtime version to the exact build inputs and test results. Publishing an image or version is a preparation step; the release decision comes when a consumer can begin using it.
Understand When Updates Reach a Function
The Update Mode Changes the Result
The runtime alias documentation distinguishes three modes:
| Runtime update mode | Alias resolution |
|---|---|
| Auto | When a new execution environment starts |
| Function update | When the function is created or updated |
| Manual | Uses the explicitly pinned runtime version |
An alias update therefore does not move every function at once. Existing execution environments can continue using the previous version. Inventory consumer update modes before setting a deadline for a patch, and include pinned functions in the remaining-work report.
Function Versions Do Not Automatically Freeze the Runtime
The consumer documentation explains that published function versions in Auto mode also follow runtime alias changes. Teams that assume a published function version freezes every part of execution need to revisit their rollback plan.
Document the combination of function version, runtime version, and update mode used by a test. Otherwise two invocations of the same published function version may be interpreted as identical deployments when they use different runtime revisions. Keep that distinction visible in incident and release tooling.
Test the Compatibility Contract on Real Workloads
Use a Consumer Matrix
Select a small set of representative functions before the first production rollout. Include native libraries, common extensions, outbound TLS, secrets access, and event formats that matter to your organization. Use the same architecture and configuration as the intended consumers. A trivial handler will leave their dependency combinations untested.
For each test, record the request, expected outcome, runtime candidate, and application owner. A useful matrix also includes failure cases. A function that returns the right value for a successful request may still mishandle timeouts or retries after an extension or language update.
Include Initialization and Reuse
Exercise new execution environments and repeated invocations. The rollout happens through environment initialization in Auto mode, so tests that only reuse a warm environment can miss the candidate. Include connection setup, initialization work, and the application's behavior after the runtime has already processed requests.
Measure against your own previous release under comparable traffic. Do not promise a performance gain because the packaging model changed. A runtime carrying a new extension or certificate library can alter startup cost even when the language version is unchanged. Keep those measurements with the release so a later regression has a useful baseline.
Promote in Stages With a Written Stop Condition
Update One Cohort Before the Next
Begin with development consumers, then a representative test cohort. Move to production only after the acceptance checks pass and the application owners understand the change. Regions can provide another staging boundary. Choose an order that exercises the workload differences you expect in production.
The documented alias operation can promote a tested candidate:
aws lambda-core update-runtime-alias \
--runtime-name company-python \
--name prod \
--runtime-version candidate-20261120
Before running it, record the previous version. This abbreviated example assumes the alias has no lifecycle settings; if it does, include the complete intended lifecycle in the update request to preserve it. Keep any lifecycle settings intact using the full request required by the current documentation. Have the promotion script read back the alias target and lifecycle settings after the update.
Choose a Bake Period That Observes Adoption
A period of quiet metrics is meaningful only if the candidate processed representative traffic. Check whether new execution environments started, whether the new version received invocations, and whether the workload covered important customer paths. A daily batch function may require a different observation window from a busy API integration.
Set stop conditions in advance: initialization failures, a sustained increase in comparable function errors, or a failed business check can pause promotion. Use thresholds appropriate to the workload and volume. A low-traffic cohort should not pass merely because a percentage-based alarm had too little data to evaluate.
Monitor Runtime Health and Application Results Together
Use the Publisher Metrics for Fleet Visibility
AWS's monitoring reference defines RuntimeInvocations and RuntimeInvocationErrors in the AWS/Lambda namespace. Runtime, alias, and version dimensions let a publisher compare releases. Queries must include the runtime dimension, and manually pinned invocations are not represented in an alias-only view of that runtime.
An illustrative rate calculation is:
runtime_error_rate = RuntimeInvocationErrors / RuntimeInvocations
Handle zero traffic explicitly when building an alarm. Compare the candidate and previous release over similar workloads, and retain consumer-level monitoring for diagnosis. Aggregate metrics are useful for seeing a shared problem, but they do not name every affected function or give you permission to inspect another team's data.
A Successful Invocation Can Still Be a Failed Customer Task
The deployment guidance says a function that completes with an application-level error response is not necessarily counted as a runtime invocation error. Monitor the application outcome as well: a processed payment, a correctly transformed event, or a completed integration job. Pick the relevant business checks with each consumer team.
Keep observability independent of the component being changed where practical. If the update changes the monitoring extension, a missing signal may be part of the failure. Use ordinary function metrics and representative external checks to confirm that the runtime's own telemetry is still trustworthy.
Make Rollback an Observed Operation
Keep the Previous Compatible Version Available
Record the prior alias target and retain its backing image. A rollback can point the alias back to that version, subject to the platform's compatibility constraints. Rehearse that operation with development consumers before the runtime becomes a shared production dependency.
aws lambda-core update-runtime-alias \
--runtime-name company-python \
--name prod \
--runtime-version stable-previous
The version name is illustrative. Replace it with the exact recorded previous version, and include any lifecycle settings that must be preserved. Never select a version from memory during an incident, and check whether returning to it would restore an unresolved security vulnerability. If so, involve the security and application owners in choosing the recovery path.
Confirm Recovery Across Update Modes
An alias reversal is a control-plane change. Watch the version-level invocation split and application health to confirm recovery as execution environments change. Functions in Function update or Manual mode may need their consumer's action; include those owners in the response.
Track two milestones: when the alias was restored and when the affected workload recovered. Keeping them separate helps explain delayed recovery and prevents an incident from closing while a pinned or rarely invoked function still needs attention. Retain the failed candidate for analysis under your artifact-retention policy.
Treat Cross-Account Sharing as Production Trust
Give Both Sides the Required Permissions
The permissions documentation explains cross-account authorization: the runtime policy and consumer identity policy must allow association. lambda:AssociateRuntimeAlias covers alias use, while explicit version pinning involves lambda:AssociateRuntimeVersion. These association permissions are checked at configuration operations; they are not a per-invocation authorization mechanism.
Review the runtime publisher as a software supplier. Its updates execute within functions using their execution-role permissions. Restrict who can publish and promote versions, and review external runtimes before adoption. Where appropriate, use reviewed upstream images to create a runtime your own team controls.
Keep a Consumer Registry Outside the Metrics
Maintain contact details and ownership for each consuming account and critical application. Runtime telemetry can show usage without providing a reliable contact list. You need a way to communicate a breaking issue, a patch deadline, or a planned retirement to the people who can act.
Review sharing policies alongside the release workflow. A policy that limits new associations does not retroactively replace code already running in consumer environments. If the publisher itself is compromised, the response needs an artifact and consumer assessment in addition to permission changes.
Protect the Promotion Credential Separately
The principal that promotes a runtime alias can affect every automatic consumer of that alias. Give that role a narrow purpose and keep ordinary application deployment credentials from also becoming runtime publisher credentials by accident. Review who can change the build inputs, publish the image, and move the alias; each step can alter the software consumers execute.
Use the release pipeline's existing identity and audit controls where they fit. The aim is a traceable chain from reviewed source to image to version to alias target. If a human must make an emergency change, capture the same identifiers and reconcile the declared configuration afterward. Otherwise the next automated deployment can reverse the incident fix without anyone intending it.
Plan Lifecycle, Retention, and Cost Before Adoption
Deprecation Is a Communication and Migration Process
The runtime lifecycle reference distinguishes deprecation from create and update block dates. Those dates do not stop existing invocations. AWS also says the publisher must notify consumers; customer-managed runtime lifecycle changes do not generate the usual automatic notifications on the publisher's behalf.
Give consumers a replacement path and enough time to qualify it. Preserve complete lifecycle settings when updating a resource because the documented update behavior can clear omitted lifecycle information. Read back the resource after automation changes it, including after an apparently harmless description update.
Retain Images for Supported and Recovery Versions
A runtime version depends on its backing image. Coordinate ECR lifecycle rules with runtime retention so routine image cleanup cannot remove an active or recovery dependency. Idle metrics alone do not establish that no function will need that version later; scheduled jobs and manually pinned consumers deserve explicit checks.
AWS's launch notice states there is no additional customer-managed-runtime feature charge, while ECR storage still applies. Your operating cost also includes builds, testing, security review, and consumer support. Estimate those costs against the deployment work you expect to remove. Centralization is worthwhile when the team can support the shared dependency reliably.
Budget for Dormant Consumers
A quiet function can still be an important consumer. Month-end reporting, disaster-recovery jobs, and infrequent partner integrations may produce little recent traffic. Add those use cases to the registry and require an owner response before retiring their runtime dependency. A traffic graph alone cannot tell you whether the next scheduled invocation will matter.
Test recovery from an artifact-retention mistake in a nonproduction environment. The exercise should establish who can restore access, which records identify the missing dependency, and how the consumer confirms recovery. Treat the result as a test of your operating process; avoid deliberately breaking a shared production runtime to discover these details.
Run a Small Adoption Pilot
Choose a Workload With a Clear Owner
Start with a noncritical but representative application whose owner can review compatibility and help rehearse recovery. Move one shared component lifecycle into the runtime, document the before-and-after deployment steps, and measure how long it takes to deliver a routine update. Include an urgent patch exercise in the pilot.
Review what the publisher had to learn and what the application team stopped doing. If every runtime change still requires bespoke coordination with each consumer, improve the contract or automation before adding more teams. The pilot should leave a repeatable release process, a consumer guide, and a tested recovery record.
Record a Release Decision That Another Team Can Review
For the pilot's final review, capture the runtime owner, supported components, alias strategy, consumer modes, candidate test results, and the previous version retained for recovery. Include the time between discovering a sample patch and observing its adoption. That duration is a useful measure of the process you are building.
Review the exceptions with the consuming team. A function left in Manual mode needs an owner and a return date, while an incompatible native dependency needs a specific compatibility plan. Do not bury either exception under a successful alias update. A new shared runtime becomes easier to adopt when the first consumer can describe both its benefits and its remaining responsibilities in ordinary operational language.
Connect the Pilot to Your Existing Architecture
Teams using compiled workloads should keep language packaging and operational ownership separate. Our Rust on AWS Lambda production guide covers a related deployment path; a new runtime management option does not automatically require migrating a working Rust function. Evaluate the actual shared-component need first.
For a platform team ready to standardize runtime releases, talk to Nandann about your AWS deployment workflow. A useful starting point is one representative function, its dependencies, the current patch process, and the person who will own the runtime after the pilot.
FAQs
What is an AWS Lambda customer-managed runtime?
It is a runtime managed as a standalone Lambda resource, with image-backed versions and aliases. Lambda Event Functions consume it while application developers continue deploying function code as zip archives.
Does AWS patch customer-managed runtimes automatically?
No. The runtime publisher owns patching and compatibility. Updated Lambda base images can provide a starting point, but the publisher must rebuild, test, publish, and roll out the replacement runtime.
Do all functions immediately receive a runtime alias update?
No. Auto mode resolves the alias at cold start. Function update mode resolves it when the function is created or updated. Manual mode uses a pinned runtime version. Existing execution environments can keep the previous version.
Can customer-managed runtimes be used with Lambda Web Functions?
No. AWS documents this feature for Lambda Event Functions and explicitly excludes Lambda Web Functions.
How do you roll back a customer-managed runtime update?
Publishers can point the affected runtime alias back to a previous compatible version. The effect depends on consumers' runtime update modes and execution-environment replacement, so verify recovery through metrics and application checks.
Can another AWS account consume our runtime?
Yes. Cross-account use requires permission from the runtime's resource-based policy and the consumer identity policy. Consumers use the runtime without needing access to its underlying ECR images.
Does runtime deprecation stop existing invocations?
Deprecation and function create/update block dates do not stop invocations. Deleting required runtime resources or making the backing image unavailable is a different failure mode that can prevent new execution environments from starting.
Work with us
Let's build something together
We build fast, modern websites and applications using Next.js, React, WordPress, Rust, and more. If you have a project in mind or just want to talk through an idea, we'd love to hear from you.
Related Articles
Engineering • 21 min
Vercel Sandbox Drives for Persistent Agent Workspaces
Design persistent Vercel Sandbox workspaces with safe single-writer mounts, read-only snapshots, regional placement, lifecycle controls, and cost limits.
9/24/2026
Engineering • 20 min
NGINX2Root: Affected Versions and Production Patching Guide
Check NGINX2Root exposure, choose upstream or vendor fixes, replace vulnerable processes, and verify production across hosts, containers, and ingress.
11/20/2026
Engineering • 20 min
Node.js 26 LTS Migration Guide for Production Teams
Plan a Node.js 26 LTS migration from Node 24 with native dependency checks, repeatable CI, Linux image validation, canary metrics, and a tested rollback path.
10/30/2026