Homeβ€Ί Blogβ€Ί AWS Architecture Series #119 β€” Three update modes, and one of them means nobody is patching you…
AWS Architecture AWS Architecture Series

AWS Architecture Series #119 β€” Three update modes, and one of them means nobody is patching you

Lambda publishes runtime patches, but whether they reach your function depends on its runtime update mode, and the three modes divide responsibility very differently. Auto means Lambda applies them. Manual means you do, and is documented as a temporary rollback mechanism only. Function update means Lambda applies a patch when you deploy - and the documentation states the consequence plainly: if you don't update your function, then Lambda doesn't update the runtime. A stable function on that mode is an unpatched function, with no deadline, no error and no deprecation notice, because Lambda imposes no time limit on using a given runtime version. What eventually arrives is a failure, such as a certificate expiry.

Verified against current vendor documentation on 20 November 2026. Pricing, limits and API behaviour were checked against the official docs on that date. Cloud services change fast — if you are reading this much later, treat the specifics as a starting point and re-check the linked sources.

Business Challenge

Yesterday's daily covered customer-managed runtimes, where a platform team owns the runtime image. That raises the prior question: on an ordinary Lambda function, who is responsible for the runtime being patched? The documentation answers it in two sentences, and the second one is the whole post.

“Lambda is responsible for curating and publishing security updates for all supported managed runtimes and container images. Responsibility for updating existing Event Functions to use the latest runtime version varies depending on which runtime update mode you use.”

Publishing and applying are different jobs. AWS does the first unconditionally. The second depends on a per-function setting with three values, and the three divide the work very differently.

1Function update mode patches on deploy, so a stable function is never patched

“For functions configured with the Function update runtime update mode, you're responsible for regularly updating your function. Lambda is responsible for applying runtime updates when you make those updates. If you don't update your function, then Lambda doesn't update the runtime.”

That is a conditional patching contract, and the condition is deployment activity. It works beautifully for a function under active development, where every release carries the latest runtime and runtime changes are synchronised with code changes you are already testing.

It fails silently for the opposite case, which is extremely common: the function that works. A webhook handler written eighteen months ago, a nightly report, a glue function between two services — nobody deploys them because nothing about them needs changing. On Function update mode those are the functions receiving no security patches at all, and the only way to tell is to compare each function's last modification date against its mode.

AWS states the remedy directly: “If you don't regularly update your function, then we strongly recommend configuring it for automatic runtime updates so that it continues to receive security updates.” The judgement it leaves to you — what counts as regularly — is the part nobody writes down.

Fix

Make the mode a function of deployment cadence rather than a default: Auto for anything you do not deploy on a known schedule, Function update only where releases are frequent enough to be a patching mechanism. Then measure it — a list of functions whose last modification predates their runtime's current version is a patching backlog, and nothing in Lambda produces that list for you.

2There is no deadline, and the failure arrives as an outage

Most deprecation mechanics in AWS come with dates. This one does not:

“Lambda doesn't impose a time limit on how long you can use any particular runtime version.”

Read as reassurance, that is a promise your function will keep running. Read as a warning, it means nothing will ever stop you, notify you, or escalate. There is no blocked deployment, no console banner counting down, no API error. The function simply continues on an increasingly old runtime version.

And then the sentence that follows it: “Functions using an earlier runtime version for an extended period might eventually experience degraded performance or issues, such as a certificate expiry, which can cause them to stop working properly.”

A certificate expiry is a precise and unsettling example, because it is a cliff rather than a slope. The function works, works, works, and then every outbound TLS connection fails on a date determined by a trust store nobody in your organisation chose. There is no gradual degradation to notice, and the triggering event is invisible from your side until it happens.

Fix

Treat runtime version age as a metric you own, because AWS is explicit that it will not enforce one. The INIT_START line in a function's logs carries the runtime version ARN, which makes the current version observable per function without an API call. Anything materially behind is accumulating risk that will present as a sudden failure rather than a warning.

3Published function versions behave differently per mode, and that is both a feature and a trap

Function versions are “an immutable snapshot of the $LATEST function code and configuration at the time that you created them” — except that the runtime underneath them is not necessarily part of the snapshot. It depends on the mode:

“In Auto mode, Lambda automatically updates the runtime version of published function versions during phase two of the runtime version rollout. In Function update mode, Lambda doesn't update the runtime version of published function versions.”

Hence: “Published function versions using Function update mode therefore create a static snapshot of the function code, configuration, and runtime version.”

That is a genuinely valuable property. A fully reproducible deployment artefact — code, configuration and runtime — is exactly what you want for a rollback you can trust, and the documentation recommends exactly that, integrating it into “continuous integration and continuous delivery (CI/CD) for fully automatic rollback in the rare event of runtime update incompatibility”.

It is also a frozen runtime serving production traffic. The same paragraph carries the condition: “When using this approach, you must update your function regularly and publish new function versions to pick up the latest runtime updates.” Reproducibility and patching are in direct tension here, and the setting that buys you one costs you the other unless you deploy.

One more sharp edge, since the setting is per version — “You can configure runtime management settings separately for each function version” — and Manual mode constrains more than the runtime: “If the $LATEST version of your function is configured to use Manual mode, then you can't change the CPU architecture or runtime version that your function uses.” A temporary rollback left in place blocks an architecture migration later, for a reason that will not be obvious.

Fix

If you use published versions with Function update mode for reproducible rollback, pair it with a release cadence and treat publishing as the patching event. And audit for functions whose $LATEST is still on Manual mode from a past incident — that is where “temporary mitigation” becomes permanent.

Architecture

Diagram: Lambda is responsible for curating and publishing security updates for all supported managed runtimes and container images, but responsibility for updating existing Event Functions to use the latest runtime version varies depending on the runtime update mode. There are three modes. In Auto mode Lambda applies runtime updates to all functions configured to use it, and the customer's responsibility is to roll back in the rare event of an incompatibility. In Function update mode Lambda applies runtime updates when you update your function, and the documentation states that if you don't update your function then Lambda doesn't update the runtime, so a function nobody deploys stops being patched; AWS recommends switching such functions to Auto. In Manual mode you are responsible for updating to the latest version, and the mode is documented for use only as a temporary rollback in the rare event of a compatibility issue. Two further deployment shapes have their own splits: with container images Lambda publishes updated base images and you are responsible for rebuilding from the latest base image and redeploying, and with a customer-managed runtime the runtime publisher rather than Lambda publishes versions with the latest patches and updates runtime aliases, while Lambda applies whatever version the alias points to according to the function's update mode and the function owner's per-mode responsibilities are unchanged. There is no deadline: Lambda does not impose a time limit on how long you can use a particular runtime version, but functions using an earlier version for an extended period might eventually experience degraded performance or issues such as a certificate expiry which can cause them to stop working properly, so the failure arrives as a cliff rather than a slope with no banner, blocked deployment or API error beforehand. Published function versions are immutable snapshots of code and configuration, and the runtime underneath them follows the mode: in Auto mode Lambda updates the runtime version of published function versions during phase two of a rollout, while in Function update mode it does not, which makes those published versions a static snapshot of code, configuration and runtime that is excellent for reproducible rollback and is simultaneously a frozen runtime unless you publish regularly. Runtime management settings are configurable separately for each function version, and if the dollar-LATEST version uses Manual mode you cannot change the CPU architecture or runtime version. Finally, the posture is enforceable rather than requested: denying access to the PutRuntimeManagementConfig API operation causes all functions to default to Auto mode, this can be applied organisation-wide with a service control policy, and for customer-managed runtimes denying lambda:AssociateRuntimeVersion prevents pinning to specific runtime versions.

Who patches, by deployment shape

ShapeAWS doesYou do
Managed runtime, Auto Publishes versions and applies them Roll back if an update breaks you
Managed runtime, Function update Publishes versions; applies them when you deploy Deploy regularly, or receive nothing
Managed runtime, Manual Publishes versions only Everything — and leave this mode quickly
Container image Publishes updated base images “rebuilding your function's container image from the latest base image and redeploying”
Customer-managed runtime Applies whatever the alias points to Publisher patches and moves the alias; owner picks the alias

Reading the middle column down, AWS's commitment is constant: it publishes. Reading the right column down, your obligation grows from react if something breaks to rebuild and redeploy. The mode is not a convenience setting; it is where you sit on that gradient.

The customer-managed shift, stated precisely

“If your function uses a customer-managed runtime, the runtime publisher, rather than Lambda, is responsible for publishing runtime versions with the latest patches and for updating runtime aliases.” And the division underneath it: “Lambda applies the runtime version that the alias points to, based on the function's runtime update mode. The function owner's responsibilities for each mode are the same as for Lambda-managed runtimes.”

So a customer-managed runtime moves the publishing half of AWS's job to your platform team and leaves the applying half with Lambda, gated by the same three modes. A function on Function update mode consuming a customer-managed runtime has two conditions to satisfy before it gets a patch: the publisher must move the alias, and the function owner must deploy. Two teams, each able to stall it, neither alerted when the other does.

The rollback capability mirrors that: “For a customer-managed runtime, the runtime publisher can also roll back a runtime alias for all functions that use it” — a blast radius worth knowing about from the consumer side.

Enforcing a posture instead of asking for one

This is the most useful operational detail on the page, and it is easy to miss. You can remove the choice: “You can restrict Lambda's runtime management controls by using AWS Identity and Access Management (IAM) to deny users in your AWS account access to the PutRuntimeManagementConfig API operation”, with the consequence stated plainly: “Denying access to this operation causes all functions to default to the Auto mode.”

That is a patching guarantee implemented as a permission boundary, applicable organisation-wide because “You can apply this restriction across your organization by using a service control policies (SCP)”, with exceptions granted case by case when a rollback is genuinely needed.

And the equivalent lever for customer-managed runtimes: “pinning a function to a runtime version also requires the lambda:AssociateRuntimeVersion permission. You can deny this action to prevent pinning to specific runtime versions.”

The pattern is the same one #116 found in the account-level policy API: the organisation's position is expressible as a denial rather than as a convention, which means it survives people who have not read the convention.

Why This Architecture Holds Up

Not imposing a deadline is the right call, given what a forced update can break

A runtime update is a change to the environment under running code, and the documentation is candid that incompatibility happens, which is why rollback exists. Hard-stopping functions on old versions would convert a security problem into an availability one on AWS's schedule rather than yours. The cost of that choice is that nothing escalates, which is why the responsibility table exists at all.

Three modes is the right number, and the middle one is genuinely useful

Synchronising runtime changes with deployments is a real engineering preference: it means a runtime change is tested by the same pipeline that tests your code, rather than arriving on a Tuesday. The mode is not a mistake. The mistake is leaving it on a function that stopped being deployed, and AWS names that case and tells you to switch.

Making the posture enforceable through IAM is better than documenting a policy

A rule that says use Auto mode is a rule people forget. Denying PutRuntimeManagementConfig makes Auto the only reachable state, with rollback available by exception. That converts a patching standard into a control, which is the difference between an intention and a guarantee.

Key Architecture Decisions

DecisionChoose thisBecause
Default mode Auto It is the only mode where patching does not depend on your activity
Function update mode Only where releases are frequent and scheduled “If you don't update your function, then Lambda doesn't update the runtime”
Manual mode Temporary rollback only, with an exit date Documented for that purpose, and it blocks architecture changes on $LATEST
Enforcing a patching standard Deny PutRuntimeManagementConfig via SCP It makes every function default to Auto rather than asking people to
Customer-managed runtimes Also deny lambda:AssociateRuntimeVersion That is the permission that lets a function pin to an old runtime version
Reproducible rollback Published versions with Function update mode They snapshot code, configuration and runtime — at the cost of freezing the runtime
Container-image functions A scheduled rebuild, not an event-driven one AWS publishes base images; rebuilding and redeploying is entirely yours
Tracking runtime age Read the version ARN from INIT_START There is no deadline and no notification, so age is a metric you have to own

The audit worth running

List every function on Function update mode with its last modified date. Anything not deployed in months is unpatched, and this is the single query that finds it. Nothing in the service surfaces this pairing.

Find every $LATEST still on Manual mode. Each one is either an incident nobody closed out or a deliberate pin nobody documented, and it silently blocks CPU architecture changes.

Check whether PutRuntimeManagementConfig is restricted at all. If anyone with function-write access can switch a function off Auto, your patching posture is a convention rather than a control.

For container-image functions, compare base-image age against your rebuild cadence. This shape has no automatic path whatsoever — AWS publishes, you rebuild, and nothing connects the two.

For customer-managed runtimes, confirm somebody owns alias movement. The publisher half of the responsibility now belongs to a team in your organisation, and a platform team that publishes versions without moving aliases has patched nothing.

Closing Thought

The long run of posts before this one was about signals that go quiet: an alarm in INSUFFICIENT_DATA, a canary that stopped running, a query that outran its own data, a subscription that skipped. This is the same shape moved from monitoring into patching, and it is arguably worse, because here the quiet thing is a security control and the eventual symptom is a certificate expiry taking down a function that nobody had touched in two years.

What makes it tractable is that AWS writes the division down. The responsibility table is unusually honest for a shared-responsibility document: it names the mode where “Lambda doesn't update the runtime”, says what to do instead, and admits there is no deadline enforcing any of it. All of the ambiguity is in one word — regularly — and that word is yours to define.

So define it, then enforce it with the permission rather than the policy document. Auto by default; Function update only where a release cadence genuinely exists; Manual with an exit date written into the ticket that created it. And keep a list of functions whose runtime version is older than their last deployment, because that list is the one thing nothing in Lambda will build for you.

Next in this series

Reliability — Amazon EC2 automatic instance recovery: which status checks it acts on, what a recovered instance keeps and what it loses, why recovery is not replacement, and what happens to an instance whose impairment is a performance condition rather than a terminal one.

Official AWS Reference

Comments

How was your experience?
Your feedback helps improve this site.
PoorExcellent