Ryz Labs/Migrations/Python 3.11 end of life
Migrations

Python 3.11 End of Life (October 2027): Plan the Move to 3.14

Python 3.11 is already security-only and goes dark in October 2027. Use the runway to land on Python 3.14 with telemetry, a test matrix and canaries.

Python 3.11 reaches end of life in October 2027; the official CPython status page gives the month, not a day. After that the project ships no more fixes of any kind for it. We recommend planning the move to Python 3.14 now, while 3.11 still gets source-only security patches, and doing it as a measured jump across three releases rather than a scramble next autumn.

Key dates

Source: the CPython release calendar and per-version PEPs (checked November 21, 2026). Python 3.13 is left out because it already moved to security-only fixes.

VersionReleasedEnd of lifeStatus on November 21, 2026
Python 3.11 (this page)2022-10-242027-10 (month only)Security-only; source releases issued as needed
Python 3.122023-10-022028-10Security-only since April 2025
Python 3.14 (our pick)2025-10-072030-10Regular bugfix builds through a planned Oct 5, 2027
Python 3.152026-10-092031-10Regular bugfix builds through a planned Oct 3, 2028

The reason to aim at 3.14 is arithmetic. Moving to 3.12 gives roughly a year past the 3.11 deadline before you start again. Python 3.14 is supported to October 2030 and still gets regular bugfix builds with installers, so one project covers several years. Python 3.15 runs a year longer still, and is a sound choice if every dependency you rely on already publishes wheels for it; for most production estates today, 3.14 is the line where the ecosystem has caught up.

What end of life means for your systems

Python 3.11 is not end of life yet, but it is already in its final phase. PEP 664 records that 3.11.9, released April 2, 2024, was the last regular bugfix release with binary installers. Since then, source-only security releases have appeared irregularly, as needed, and PEP 664 expects them to continue until approximately October 2027. Practically, only security patches reach 3.11 now, and somebody (your image publisher, your distribution, or you) must compile each one.

Come October 2027, the devguide status key kicks in: support ends, the branch freezes, and nothing further lands. Prepare along three lines.

We will not guess which third-party libraries drop 3.11 and when, since each maintainer decides that separately. Read the changelogs of your five most critical dependencies and note their stated support ranges.

Find your exposure

A 3.11 interpreter can sit in a dozen places besides the main service image. Look in each of these.

Our EOL deadline radar (no cost, no signup) takes a pasted manifest, lockfile or Dockerfile and returns a dated report, which is a quick way to share the scope with the people who own each service.

What changes in the upgrade

A 3.11 codebase moving to 3.14 meets three sets of release notes. Below are the changes most likely to matter, drawn from the official What's New pages for 3.12, 3.13 and 3.14.

Packaging: no distutils, no implicit setuptools

In 3.12 the distutils package was deleted, and new virtual environments no longer come with setuptools. Two kinds of code break: build scripts importing distutils, and application modules relying on pkg_resources or easy_install helpers while running. The official guidance is to declare setuptools explicitly where it is truly needed; for version lookups, importlib.metadata is the standard library answer.

Removed modules: imp, asyncore, smtpd and the PEP 594 list

Version 3.12 removed imp, asyncore, asynchat and smtpd. Version 3.13 then removed the remaining PEP 594 "dead batteries": cgi, cgitb, crypt, telnetlib, pipes, imghdr, sndhdr, uu, nntplib, mailcap, audioop and others, plus 2to3. Python 3.11 already warned about all of them, so a run with deprecation warnings enabled will find them. The 3.13 notes list replacements and PyPI redistribution packages for most.

Security-relevant API removals and defaults

Version 3.12 removed ssl.wrap_socket(), which the release notes say sent no SNI and did not validate hostnames. Version 3.13 made ssl.create_default_context() set VERIFY_X509_PARTIAL_CHAIN and VERIFY_X509_STRICT by default, which can reject certificates that older builds accepted, so test against internal certificate authorities early. In 3.12, tarfile and shutil.unpack_archive gained a filter argument to limit surprising or dangerous archive features; adopt it where you extract uploads.

Stricter parsing and tooling output

Under 3.12, invalid escapes in normal strings (for example "\d" in a regex) raise SyntaxWarning rather than DeprecationWarning; the docs say SyntaxError comes later. PEP 701 moved f-strings into the grammar, which changed tokenize output, so linters, formatters and code generators pinned to old versions may misbehave. The os module also stopped accepting bytearray and memoryview paths.

Runtime semantics that tests may miss

In 3.12, functools.cached_property dropped its cross-instance lock, so a getter can run twice when threads race. In 3.13, PEP 667 made locals() return an independent snapshot in functions, and pathlib glob patterns ending in "**" now return files as well as directories. These rarely fail loudly; review code that relies on them.

Annotations, pickling and descriptors in 3.14

Python 3.14 evaluates annotations lazily under PEP 649 and PEP 749, with a new annotationlib module. The docs say most annotated code needs no change, but frameworks that introspect annotations at import time (validation, serialization, dependency injection) should be tested. functools.partial became a method descriptor, so partials stored as class attributes behave differently unless wrapped in staticmethod(). pickle now raises PicklingError for more failure types, so update except clauses that caught the old exceptions.

Concurrency defaults in 3.14

Linux hosts (and every Unix except macOS) now start multiprocessing and ProcessPoolExecutor workers with forkserver rather than fork; Windows and macOS stay on spawn. Calling asyncio.get_event_loop() with no current loop now fails with RuntimeError, and the child watcher classes are gone. The recommended pattern is asyncio.run().

What you gain

Beyond longer support, 3.12 through 3.14 add the PEP 695 type parameter syntax, a per-interpreter GIL, low-impact monitoring for profilers, a new interactive shell, template strings, Zstandard compression in the standard library, and a free-threaded build that 3.14 lists as officially supported but optional. Treat free-threading as a separate evaluation after the upgrade, not part of it.

The upgrade plan

With the deadline a year out, the plan can be telemetry-driven rather than heroic.

Inventory and baseline

Publish the exposure list, one named owner per service. Record request latency, memory footprint and job durations as they stand today. Python 3.11 was itself a big speed release, so you want hard numbers showing 3.14 holds up for your workload. Flag every compiled dependency and whether cp314 wheels exist yet.

Compatibility testing

Begin harvesting deprecation signals right away. Set PYTHONWARNINGS so staging surfaces every DeprecationWarning, and pass -Werror in CI so a fresh one fails the build. Pipelines should exercise 3.11 and 3.14 in parallel; large codebases benefit from an extra 3.12 job, which isolates packaging removals. Land fixes on main so one commit passes under both interpreters.

Staged rollout

Dual-compatible code means you deploy it on 3.11 first, then change nothing except the base image. Promote 3.14 one service at a time, lowest risk first, sending a small share of requests to each new build. Queue consumers and batch jobs get a separate canary, given the forkserver change.

Cutover and rollback

Raise the 3.14 share gradually while 3.11 images stay published. One commit serving both interpreters makes reverting a matter of redeploying yesterday's tag; no code revert needed. Pause library bumps during this window so a regression can only be blamed on one variable.

Cleanup

Delete 3.11 jobs from pipelines, raise requires-python, regenerate lockfiles so cp311 wheels disappear, and strip version-conditional branches. Put Python 3.14's own dates on a shared calendar so its successor upgrade becomes routine. If you still have 3.10 services, our Python 3.10 end-of-life plan covers that harder jump.

PhaseGoalKey techniqueExit criteria
Inventory and baselineNamed owner for each 3.11 runtimeManifest sweep, radar reportLatency, memory, job durations recorded
Compatibility testingSingle commit green under 3.11 plus 3.14PYTHONWARNINGS telemetry, parallel pipelinesZero new deprecation hits
Staged rolloutEach service proven on its new imageSwap base image only, small request share firstErrors, latency at or below today
Cutover and rollbackEvery request served by 3.14Gradual share increase, yesterday's tag publishedOne release cycle without interpreter-caused incidents
CleanupNothing references 3.11Bump requires-python, relockScanners report clean

Risk matrix

RiskLikelihoodImpactMitigationEarly warning
Work slips until October 2027 arrivesMediumHighDated plan and owners now, reviewed monthlyInventory still incomplete next spring
Compiled package publishes no cp314 wheelMediumHighAsk maintainers, switch packages, or pause at 3.13Resolver errors, compilers invoked during installs
Stricter TLS verification rejects internal certificatesMediumHighTest against every internal CA and fix chainsCertificate verify errors in staging
Annotation introspection changes framework behaviorLowMediumUpgrade validation and serialization libraries firstSchema or model errors at import
Forkserver default trips ProcessPoolExecutor jobsMediumMediumPass state explicitly; choose a start method deliberatelyPickling tracebacks from child processes
Old linters or code generators break on new tokensMediumLowBump dev tooling alongside the interpreterTool crashes in pre-commit hooks
Thread race appears after cached_property changeLowMediumAdd explicit locks in non-idempotent gettersDuplicate side effects in logs

Typical team shape

Code written for 3.11 is already fairly modern, so this project leans toward coordination over rewriting. Start with platform work: a platform specialist (see our DevOps engineers) rebuilds container images, adds pipeline jobs and wires progressive delivery. Alongside, Python specialists clear deprecations, chase compiled packages for cp314 builds and verify framework behavior under lazy annotations. Someone senior sequences services, chairs canary reviews and keeps owners honest about dates. Estates changing clouds anyway sometimes fold this work into a cloud migration.

Many teams begin with a pod of 3 to 5 senior engineers (a tech lead plus engineers), and a full pod is about seven. Ryz engineers on your team start from $7,000 per month (our published range is $7,000–$15,000 per engineer per month, mostly mid-level to senior), quoted per team. Ryz engineers work on your team, reporting to your leads. Got spare capacity internally this year? A plan review alone might be enough, and we will say so. Ready to talk? Scope your team.

Related

FAQ

Is Python 3.11 still safe to run after end of life?

Today, yes, within limits: source-only security releases continue until October 2027, while ordinary bug fixes stopped in 2024. Once that month passes, CPython freezes 3.11 completely, meaning newly discovered vulnerabilities get patched only in later versions. Aim to finish well before October 2027.

Which version should we upgrade to?

Go to 3.14: support lasts until October 2030 and regular bugfix builds still ship. Choose 3.15 (through October 2031) only once every critical package publishes wheels for it. Treat 3.12 or 3.13 strictly as a temporary stop, since both already receive security patches alone.

How long does the upgrade take?

Duration depends on service count, compiled packages awaiting cp314 wheels, reliance on deleted modules or runtime setuptools, framework annotation introspection, multiprocessing usage, plus test coverage depth. Running pipelines under both interpreters reveals most of that early.

Can we pay for extended support?

The Python project does not sell extended support; its schedule simply ends in October 2027. Linux distributions and cloud providers sometimes patch their packaged Python on their own timelines, so ask yours directly. Use that only as a bridge.

What does it cost to bring in engineers?

Engineers start from $7,000 a month each, with senior engineers toward the $15,000 end of our published range. Multiply headcount by months by monthly rate for a budget figure. Every quote is per team and arrives with a scoped plan and the named engineers who would do the work.

Questions we didn't answer? Email info@ryzlabs.com.

Thanks — your message has been sent. We’ll get back to you soon.

Something went wrong while sending your message. Please try again or email info@ryzlabs.com.

Explore Ryz Labs

Software development servicesAI development companyIndustriesStaff augmentationAI pod teamsNearshore software developmentHire engineers by roleEngineer ratesGuidesBuyer guidesCase studiesHow we vet engineers

Ryz Labs

Senior engineers on your team. AI pod teams that ship.

Tell us what you're building. You get a scoped plan, a price and the names of the people who would do the work.

  • Only the top 1% of tens of thousands interviewed make it
  • On US business hours, including New York hours
  • Trusted by Fortune 500 engineering teams

Tell us who you need

A Ryz partner replies with a scoped team plan.

Start a conversation →

Prefer to talk? Book a 15-min call →