SecurityIdentity

Auth0's lazy migration changes on 20 January 2027, and half-imported users won't fix themselves

Auth0 is retiring Legacy Custom DB User Import. From 20 January 2027, custom database connections that import users create a full profile during a password reset or a blocked first login. Users already stuck halfway stay stuck, so test the new behaviour now and clean up the old records.

Cohash Security Practice November 2026 13 min read 7 chapters 3-question check
part 34 of 37 · Platform releases, explained from scratch
UNTIL 20 JAN 2027 Reset, then walkaway Hidden partialrecord Missing from theUsers list AFTER 20 JAN 2027 Full profile on thespot Built from Get Userdata Old partials stay asis

the ideaA reset or a blocked first login now creates the full profile straight away.

after reading, you can
  • Spot the users who got stuck halfway, and see why Auth0's Users list and API never showed them
  • Test the new import behaviour in a dev tenant with the Dashboard toggle before Auth0 forces it
  • Clean up the users already stuck halfway, because the January change won't fix them

If your Auth0 tenant still pulls users across from an old database as they log in, the way that import finishes is about to change. Auth0 retires Legacy Custom DB User Import on 20 January 2027. Turn the new behaviour on in a test tenant first, and clean up the users who are already stuck halfway, because the change won't touch them.

in plain wordsEnd of life: 20 January 2027

Half-finished moves into Auth0 now finish on the spot, login or no login

Lots of companies move to Auth0 without forcing everyone to reset a password. Auth0 checks each person's password against the old database the first time they sign in, then copies them over. Sometimes that first visit doesn't end in a login. Someone resets a password and wanders off, or Auth0 blocks the login because the password showed up in a breach. Until now, those people could end up half-copied: their details were in Auth0, but nobody could see them in the admin screens. From 20 January Auth0 finishes the copy at that moment instead. People already caught halfway stay that way, so somebody has to fix them by hand.

think of it like this

Think of a building switching tenants to new keys. Your old key gets checked at the door and a new one is cut for you. Turn back before you walk in, and the new key used to sit in a drawer with no name on the list. From January, reception writes your name down the moment the key's cut.

who should care
  • Auth0 tenant admins
  • Developers who own custom DB scripts
  • CIAM product owners
  • Support teams handling login tickets
  • Security teams running breach checks
  • Business owners mid-migration
chapter 01

Why a quiet behaviour change still needs a test

20 Jan 2027End of life. Auth0 switches every remaining tenant over automatically
100 daysFrom the 12 October deprecation to end of life
6 monthsThe window Auth0 says it aims for whenever possible
0Existing partial records the change repairs

This one is short notice by Auth0's own standard. Its migration process page says it tries to give at least six months between announcing an end of life and enforcing it. Here it's about three, and the holidays sit in the middle. If your change freeze starts in mid-December, you've really got about five weeks to test.

Nothing breaks for people who log in normally. The risk is in the edges, and in what you've built around them. A user who clicks a reset link now gets a full Auth0 profile on the spot, built from whatever your Get User scriptdefinitionYour script that asks the old database whether a person exists and what's on their record. Auth0 runs it at sign-up, password changes and logins. From January its answer can become the stored profile, so sloppy output sticks. returns. Reports, exports and sync jobs that read users through the Management API will start counting people who've never logged in to Auth0. Those people used to be invisible.

Then there's the backlog. Auth0 says profiles already stuck in a partial importdefinitionA half-finished migration. Auth0 has stored the user's data and password, but there's no normal user profile, so the person doesn't appear in the Dashboard or the Management API. stay stuck, even when the person goes through the same flow again. One developer on Auth0's community forum described what a stuck record can look like from the outside: a reset flow where the user lookup comes back empty, but creating the user fails with "The user already exists." Auth0's migration guide reads that as a record that's in its internal store but not in your tenant.

what changesOne forgotten password and the two ways that first visit can endThis person still only exists in the old database and has forgotten their password.
  1. 01 Asks for a reset

    Auth0 runs your Get User script against the old database. It finds them, so the reset email goes out.

  2. 02 Clicks the link

    Here's the change. Auth0 builds the full profile as soon as the link's clicked, from Get User data, and the old password doesn't come across.

  3. 03 Finishes the reset, or doesn't

    Under the legacy import, someone who finished the reset and then never logged in could leave a hidden partial record. Now they're already a normal user, and you'll see them in the Dashboard.

  4. 04 Comes back later

    If they closed the tab before setting a password, their next login goes to Auth0's own store, which holds no password for them yet. That's our reading of Auth0's pages, so plan on another reset.

  5. 05 Resets and signs in

    They finish the reset and the new password is saved in Auth0. From then on the old database has nothing to do with how they log in.

Step four is our reading, so test it before you rely on it. Auth0's migration guide says the Login script only runs for users who aren't in the Auth0 store yet. The deprecation notice says a reset imports the user without their old password. Put the two together and someone who abandons a reset can't log in with the old password any more. Auth0 doesn't say this in so many words, so try it in a dev tenant and write down what you see.

chapter 02

What changes, and what stays exactly as it is

The change at a glance

changedWhen the import finishes

A first-time user gets a standard profile during the reset or blocked-login flow itself. Before, the import only completed after a successful login.

changedPassword reset imports

Opening the reset link now imports the user from whatever Get User returns. Their old password stays behind, so they only get a working password by finishing the reset.

changedFirst login blocked by a breach check

Breached password detection blocking a first login used to leave a partial import. Now the user is fully imported. As we read the blocking rules, they still can't log in until they change the password.

changedWho shows up in the Users list

Users caught by these flows appear in the Dashboard and come back from the Management API user endpoints. Before, they did neither.

newA Dashboard toggle to switch early

Auth0 lists a migration toggle called Legacy Custom DB User Import. Tenants that qualify can switch early, so you can test it in a quiet week you pick.

removedThe old behaviour, on 20 January

Tenants created by 12 October 2026 keep the legacy import until 20 January 2027. After that, Auth0 enforces the new one for anyone who hasn't switched.

changedExisting partial records: no change

Profiles already stuck halfway stay that way, even if the person runs the same flow again. You clean these up yourself.

tableFirst visits, case by case: what the legacy import did and what you'll get from 20 January
SituationLegacy importFrom 20 January 2027
First login succeedsImported with the same ID and passwordNo change
Reset completed, but the user never logs in with the new passwordPartial import, hidden from Dashboard and APIAlready a full profile, imported from Get User data when the reset link was opened
First login blocked by breached password detectionPartial importFull profile. Blocking should still demand a password change (our reading)
Network failure cuts a first login shortCould leave a partial importAuth0's notice doesn't describe the new outcome
User already in a partial stateStuckStill stuck. Clean up by hand
Tenant created after 12 October 2026Not offeredNew behaviour already applies, as we read the notice

The table carries most of it, but one row deserves a second look. Auth0 lists network failures that interrupt a login as one cause of partial imports, then only describes the new outcome for the reset and breach cases. So don't assume every way of ending up half-imported goes away in January. Keep watching for duplicate-user errors after the switch, too.

The Auth0 dates on the same page

  1. 12 Oct 2026
    Legacy Custom DB User Import deprecated

    Tenants created by this date keep the old behaviour until the deadline, unless they switch early.

  2. 7 Nov 2026
    Today: about ten weeks left

    Enough time for a test tenant and a cleanup, provided someone owns it before the holidays.

  3. 20 Jan 2027
    End of life for the legacy import

    Any tenant that hasn't switched gets the new behaviour automatically. Auth0 doesn't list a way to stay on the old one.

  4. 4 Mar 2027
    Uncapped user profile data ends

    Auth0 brings in a 50KB profile limit. A Get User script that returns bulky metadata now feeds full profiles, so check sizes.

  5. 30 Apr 2027
    Hooks stop running

    Hooks are already read-only. If you still have any, plan that move alongside this one.

  6. 31 Jan 2028
    Rules stop running

    The last of the old extensibility goes. Plan both moves to Actions alongside this one.

side by sideRun the same connection both ways and here's what you'd notice
Legacy import
  • A user is only imported after a successful login
  • Abandoned resets can leave hidden partial records
  • First logins blocked by a breach check can end up half-imported too
  • The Users list misses people who started moving but never finished
  • DUPLICATED_USER errors turn up later, with no obvious cause
New import
  • Reset and breach-block flows import the user straight away
  • Get User data becomes the stored profile
  • Users list and API counts now include people who've never logged in
  • Someone who walks away from a reset still ends up a real user, just without a password
  • Old partial records still need a manual fix
chapter 03

Pick your route before Auth0 picks the date for you

You can do nothing. Auth0 flips every remaining tenant on 20 January regardless, so what you give up is choosing when the problems show up. The table lays out the routes we'd weigh. For most teams, switching early is the right call.

tableThree ways to handle the deadline
RouteWhat you doEffortMain risk
Switch early with the toggleTurn on the new behaviour in dev, then staging, then production, on dates you pickLow to medium: mostly testing and checking scriptsLittle, if Get User returns clean, consistent profiles
Wait for Auth0 to enforce itChange nothing and let 20 January happenNone up frontYou find problems in production, possibly during a freeze
Finish the migration firstMove the rest of the users across, check counts, then turn the scripts into no-opsMedium to high, depending on how many users are leftMixing methods can cause DUPLICATED_USER errors, which Auth0 warns about

The third route only makes sense when most users have already moved. Auth0's guide says to confirm every user from the old store is in Auth0 before disconnecting. Then you change the Login and Get User scripts to return nothing, and leave Import Users to Auth0definitionThe switch on a custom database connection that turns lazy migration on. With it on, Auth0 copies each user into its own store after a successful login. switched on. One developer on Auth0's forum hit a related trap in a different setup. Accounts created while the connection ran in passthrough mode, before a bulk import, couldn't log in once the old database was cut off.

remove-partial-user.shexample output
# example: removes one stuck user, so they can log in and migrate again
# needs a Management API token with delete:users
CONN_ID="con_XXXXXXXXXXXX"
EMAIL="[email protected]"
curl -s -X DELETE \
  -H "Authorization: Bearer $MGMT_TOKEN" \
  "https://$TENANT.auth0.com/api/v2/connections/$CONN_ID/users?email=$EMAIL"
# afterwards the user logs in or resets, and the import starts over

That call is Auth0's Delete a connection user endpoint, one of the fixes its migration guide gives for DUPLICATED_USER errors. It works by email, one user at a time, and only on database connections. Run it in a dev tenant first. Make sure the person really is stuck, because deleting a working user throws away their Auth0 data. URL-encode the email if it contains a plus sign, and check each response code before you move to the next user.

chapter 04

What to do before 20 January

Who does what

Business ownerthis week
  • Ask whether any Auth0 connection still has Import Users to Auth0 on and talks to an old database.
  • Name one person who owns the switch date. Without that, the change happens on Auth0's date, mid-freeze.
  • Ask support how many login tickets mention a reset that didn't work. That's your baseline.
Auth0 adminthis week
  • List every custom database connection and note which have Import Users to Auth0 switched on.
  • Look for the Legacy Custom DB User Import toggle in the Dashboard. Check your tenant can use it before you plan around it.
  • Search tenant logs for DUPLICATED_USER and "user already exists" errors over the last few months.
  • Check whether breached password detection blocks logins on these connections. That's one of the two paths that changes.
Developersby mid-December
  • Make Get User return the same profile shape and the same user_id as Login. Compare them for real accounts.
  • Give both scripts timeouts and clear error messages, as Auth0's best-practice page asks. A hung call to the old database shouldn't look like a wrong password.
  • Test in a dev tenant: reset and walk away, a breach-blocked first login, then a normal first login.
  • Check what downstream code does with users who have no password yet and haven't logged in.
Support and securitybefore the switch
  • Write the support reply before the switch, for users whose old password may stop working after an abandoned reset. Test that case in dev, because someone will call on day one.
  • Keep breached password detection on. Auth0's notice changes how the import finishes, and nothing in it turns the blocking off.
  • Watch tenant logs for a week after the switch, and compare duplicate-user errors with your baseline.

The order we'd run it in

  1. 01
    Find the connections

    List custom database connections with import turned on. Any connection that only authenticates against the old database, with import off, isn't what Auth0's notice describes.

  2. 02
    Count the stuck users

    Search tenant logs and the old database for people who started a reset or a login but aren't in Auth0's Users list. Real-time logs show console.log output from your scripts, which helps.

  3. 03
    Fix the scripts

    Get User now writes the profile, so give it the full set of fields and the same stable user_id that Login returns. Keep metadata small with the 50KB profile limit coming in March.

  4. 04
    Flip the toggle in dev

    Run the three test cases: reset and walk away, breach-blocked first login, normal first login. Check each user in the Dashboard and through GET /api/v2/users.

  5. 05
    Clean up old partials

    For each stuck user, Auth0's guide says delete the connection user, then have them log in or change their password to migrate again. Deletion can't be undone, so work in small batches and record each email and response first.

  6. 06
    Switch production on your date

    Pick a quiet week before your freeze, tell support, and watch logs for the next few days. Don't leave it for Auth0's date in January.

chapter 05

Harden the migration so the next change hurts less

before

Before: half-imported users disappear

A first visit that doesn't end in a login can leave data inside Auth0 that neither the Dashboard nor the API will show you.

Before: half-imported users disappear A first visit that doesn't end in a login can leave data inside Auth0 that neither the Dashboard nor the API will show you. 01 · OLD SYSTEM 02 · AUTH0 CUSTOM DB 03 · AUTH0 STORE checks reset, walked away login worked Legacy user database behind your API Login and Get Userscripts import switched on Partial import hidden from Users and API Full user only after a login © Cohash · cohash.com
01 · OLD SYSTEM02 · AUTH0 CUSTOM DB03 · AUTH0 STORE Legacy user database: behind your API Legacy user database behind your API Login and Get User scripts: import switched on Login and Get User scripts import switched on Partial import: hidden from Users and API Partial import hidden from Usersand API Full user: only after a login Full user only after a login checks reset, walked away login worked © Cohash · cohash.com
after

After: every started import becomes a real user

Reset and breach-block flows create a standard profile from Get User data. Your scripts and logs decide how clean that profile is.

After: every started import becomes a real user Reset and breach-block flows create a standard profile from Get User data. Your scripts and logs decide how clean that profile is. 01 · OLD SYSTEM 02 · AUTH0 CUSTOM DB 03 · AUTH0 STORE 04 · WATCHING checks reset, login or block errors Legacy user database marked as migrated Login and Get Userscripts same profile, stable ID Full user profile visible in Dashboard andAPI Tenant logs duplicate-user alerts © Cohash · cohash.com
01 · OLD SYSTEM02 · AUTH0 CUSTOM DB03 · AUTH0 STORE04 · WATCHING Legacy user database: marked as migrated Legacy user database marked as migrated Login and Get User scripts: same profile, stable ID Login and Get User scripts same profile, stable ID Full user profile: visible in Dashboard and API Full user profile visible in Dashboard and API Tenant logs: duplicate-user alerts Tenant logs duplicate-user alerts checks reset, login or block errors © Cohash · cohash.com

Durable fixes

  1. 01
    Put the old database behind a narrow API

    Auth0 recommends a protected API with a few endpoints, such as read user and change password, over exposing the database itself. Use an IP allowlist of Auth0's outbound addresses only as one layer, since those addresses are shared across tenants.

  2. 02
    Mark users as migrated at the source

    Auth0 suggests flagging each user in the old store as migrated. That stops someone you deleted in Auth0 being quietly imported again the next time they try to log in.

  3. 03
    Delete from the old store as a separate job

    Auth0 advises against deleting users inside the Login script, because an error halfway through can lose the account. Run deletion as its own process once counts match.

  4. 04
    Backfill missing metadata with an Action

    An interrupted login or reset can leave a user without their user_metadata or app_metadata. Auth0's fix is an Action that spots the gap and fetches the data from the old store.

  5. 05
    Set a date to finish

    Lazy migration never ends for people who don't come back. Decide when the rest get a bulk move or a forced reset, so the old database can finally be retired.

chapter 06

If it goes wrong

When logins or resets fail after the switch

Most problems here are a support surge or a script bug, not an attack. Treat it as a security incident only if accounts appear that nobody asked for, or a reset goes through for the wrong person.

  1. 01Confirm the causefirst hour
    • Read tenant logs for the failing users. A DUPLICATED_USER error and a wrong password need different fixes.
    • Look the user up in the Dashboard. If they're there with no password, they probably walked away from a reset.
    • Open Real-time logs and replay one case to see what Get User and Login returned.
  2. 02Keep people workingsame day
    • Send anyone who walked away from a reset a fresh link. As we read Auth0's notice, finishing it is what gives them an Auth0 password, so don't make them wait.
    • Give support a two-line explanation they can repeat. Without one, users will assume their account's been wiped.
    • Auth0's notice doesn't say whether the early toggle can be turned back off. Find out in dev, before you need it.
  3. 03Fix the recordsfirst week
    • Delete each stuck user's connection record by email, then ask them to log in or reset again. The import starts over from scratch.
    • Correct any profiles built from bad Get User data, and fix the script so it doesn't happen again.
    • Backfill missing metadata with an Action that reads the old store.
  4. 04If something looks hostileimmediately
    • Reset the affected users' passwords, end their sessions, and check what they accessed.
    • Check the old database and its API for unexpected calls. The scripts hold credentials to it.
    • Rotate the secrets your custom database scripts use, and involve legal if customer data was exposed.
  5. 05Learn from itafter
    • Add the three test cases to your regression suite for any change to the scripts.
    • Set a finish date for the migration, so you aren't running two user stores at the next deprecation.

Four illustrative situations

01 Dormant user old database only 02 Reset link clicked, then left 03 Full profile shows in reports
scenario 01Medium risk
A subscription app halfway through a lazy migration
the setup
A consumer subscription service moved to Auth0 a year ago with import on. Most active users have moved. Thousands of dormant ones still only exist in the old database.
what happens
After the switch, the next marketing email sends dormant users to reset their passwords. Each click creates a full Auth0 profile, so the user count jumps and the analytics team asks why.
what to do
Tell analytics and finance before you switch. Decide whether a profile created by a reset click counts as a migrated user in your reports.
01 First login breached password 02 Blocked breach detection 03 Imported full profile 04 Passwordchanged then signs in
scenario 02Low risk
A B2B portal with breach detection on
the setup
A distributor's partner portal blocks logins that use breached passwords. Some partner users haven't logged in since the migration started, and their passwords turn up in old breaches.
what happens
Under the legacy behaviour, a blocked first login could leave them half-imported and stuck with DUPLICATED_USER errors. After the switch they're imported straight away, then asked to change the password.
what to do
Keep detection on. Check that the reset email and the support script make sense to someone who was just told their password was in a breach.
01 Get User email-based ID 02 Login database key ID 03 Duplicates same person twice
scenario 03High risk
A retailer with a messy Get User script
the setup
A retailer's Get User script was written quickly years ago. It returns only the email and builds user_id from the email address, while Login uses the database key.
what happens
Once the reset path imports from Get User, these users get profiles with no metadata and an ID that doesn't match Login. That's the setup for duplicate users later.
what to do
Fix the script before the toggle goes on. Return the same fields and the same user_id from both scripts, and test five real accounts.
01 Partial users from old resets 02 Delete andretry per user 03 Counts match old vs Auth0 04 Scripts off import stays on
scenario 04High risk
A team ready to switch off the old database
the setup
A software company has moved nearly all its active users and wants the old database gone next quarter. Some users hit broken resets last year and never came back.
what happens
Those users sit in a partial state. The January change won't repair them, and once the scripts become no-ops they can't migrate at all.
what to do
Find and clear the stuck users first, check counts against the old store, and only then change the scripts to return nothing. Leave Import Users to Auth0 on.
chapter 07

How Cohash helps

We plan and run Auth0 migrations, including custom database connections. For this change that means reviewing your Login and Get User scripts, running the test cases in a dev tenant, and clearing stuck users before you switch. If you've still got Rules or Hooks to move, read our post on the Auth0 Rules and Hooks deadlines too. See our Auth0 page for how we work, or book an assessment if you'd like us to look at your tenant.

key takeaways

What to take from this

  1. 01

    Auth0 retires Legacy Custom DB User Import on 20 January 2027. After that, someone who clicks a reset link or gets breach-blocked on a first login is imported right away, even if they never log in.

  2. 02

    Users already stuck in a partial import stay stuck. Find them and clear them with Delete a connection user, then let them migrate again.

  3. 03

    Whatever Get User returns becomes the stored profile, so make it match Login and use the same stable user_id.

  4. 04

    Switch early with the Dashboard toggle in a dev tenant, then production, before your holiday freeze.

  5. 05

    Expect user counts to rise. As we read Auth0's pages, some abandoned-reset users will need a fresh reset too, so brief support and analytics first.

platforms in this noteAuth0 →
fact-checked November 2026 against vendor and official documentation · where to go next
  1. How Cohash delivers Auth0: scope, roles and architecture
  2. Hire vetted Auth0 engineers
  3. Customer identity
  4. Book a 30-minute working session with a senior engineer
01What is Auth0 Legacy Custom DB User Import?

It's the old way Auth0 finished lazy migration on custom database connections with Import Users to Auth0 switched on. A user was only fully imported after a successful login, so abandoned resets and breach-blocked first logins could leave partial records. Auth0 deprecated it on 12 October 2026 and ends it on 20 January 2027.

02Do I have to do anything before 20 January 2027?

Auth0 switches remaining tenants automatically, so you don't have to act for the switch itself to happen. You should still test the new behaviour with the Dashboard toggle, check your Get User script, and clean up users already stuck in a partial import, because the change won't fix them.

03Does this affect custom database connections with import turned off?

Auth0's notice only describes connections configured to Import Users to Auth0. If a connection just authenticates against your own database and never imports, it isn't the setup the notice talks about. Check each connection's settings rather than assuming.

04We already have users stuck halfway. What happens to them?

They stay stuck. Auth0 says the new behaviour won't touch them, even if they reset or log in again. Its migration guide's fix for duplicate-user errors is to delete the user with the Management API, using Delete a User or Delete a connection user. Then they log in or change their password and migrate again.

05Will users have to reset their passwords?

Users whose first login succeeds won't notice anything. Someone who clicks a reset link gets imported without the old password, so as we read Auth0's pages they'll need to finish a reset to log in. Test that path in a dev tenant.

06How do I switch to the new behaviour early?

Auth0 lists a Dashboard migration toggle called Legacy Custom DB User Import for tenants that qualify. Turn it on in a development tenant first, run your test cases, then switch production on a date you choose.

07Our Auth0 user count went up after the change. Why?

People who click a reset link or are blocked on a first login now get a standard profile straight away. Before, someone who finished a reset but never logged in, or was breach-blocked, could become a hidden partial record. Reports that count users through the Dashboard or Management API will include them.

up next in this track

Keep the thread going.

What shipped, what changed underneath, and what it means for your upgrade.

  1. 01HashiCorp Vault 2.2 explained: TPM login, post-quantum PKI and the October fixes
  2. 02Upgrading to SailPoint IdentityIQ 9.0: what breaks and what to fix first
  3. 03Terraform 1.17 explained: what's new, who it touches and how we'd upgrade
  4. 04BeyondTrust Remote Support zero-day: patch it, then check who got in
  5. 05Patch PHP and Node.js this week: what broke and who's exposed
  6. 06OpenShift support dates through 2027: which clusters run out first and how to plan the upgrades
  7. 07Oracle's October security patches: what to fix first in EBS, PeopleSoft and Access Manager
  8. 08Oracle Java drops four root certificates over eMudhra: patch, then test what breaks
  9. 09Delinea Secret Server auth bypass: why the FIDO2 hotfix isn't enough
  10. 10IBM Verify Access flaws let attackers run code without a login: patch to 11.0.3.2
  11. 11Foundry Workflows retire on December 1. We'd start moving yours to Agent Framework now
  12. 12Vertex AI is retiring text-embedding-005 and three other embedding models: how to re-embed before search breaks
  13. 13dbt drops v1.3 to v1.7 from its platform on January 31, 2027: get pinned jobs onto a release track before they're deleted
  14. 14Brotli CVE-2026-111497 is now on CISA's exploited list, and you probably run more copies than you think
  15. 15Auth0 moved the Rules and Hooks deadline: Hooks stop on 30 April 2027, Rules on 31 January 2028
  16. 16Still on Okta Classic Engine? Three features stop working on March 5, 2027, and two of them block the upgrade
  17. 17Patched GitLab, still exposed: the CI regex bug CISA lists as exploited, and the Ruby step people miss
  18. 18Patched Ivanti Connect Secure in October? Two more exploited bugs, and the AD cleanup
  19. 19Patch roundup, week of Oct 26: upgrade Secret Server today, then work down the list
  20. 20UiPath 2023.10 support has run out and 2024.10 is next. What we'd upgrade first
  21. 21Password Safe 24.3 runs out of support in December, and 26.3 is still one upgrade away
  22. 22Upgrade Entra Connect Sync before April 2027 and move users off Microsoft's SMS codes
  23. 23Chrome drops XSLT on 17 November. What breaks in InterSystems, and the fix for your version
  24. 24Agent Builder, Evals and saved prompts shut on 30 November. Here's what to pull out first
  25. 25BeyondTrust Remote Support and PRA 24.3 lose support in November, and there's no one-step upgrade
  26. 26OpenShift 4.19 is running out of support. Do you park on 4.22 or keep going to 5.0?
  27. 27Terraform Enterprise 2.1 moves VCS ingress into your agents. What to change before October 2027
  28. 28Mule 4.12 Edge leaves standard support this month. Upgrade to 4.13 before CloudHub does it for you
  29. 29RSA SecurID primary support ends in stages from December. Here's how you get to 8.9
  30. 30Delinea Secret Server login bypass: why 12.2.7 won't save you from this 9.9
  31. 31Entra password reset won't take directory phone numbers from February 2027. Who gets stuck?
  32. 32Linux kernel CVE-2026-98432: why switching off MPTCP won't save you, and what to patch
  33. 33Patch roundup, week of Nov 2: fix Linux and WS_FTP first, then work down the list
  34. 34Auth0's lazy migration changes on 20 January 2027, and half-imported users won't fix themselves
  35. 35Your Databricks AI Functions need Runtime 17.3 LTS by January 2027, even if 15.4 is still supported
  36. 36SonicWall's SSL VPN bug lets a valid password skip SAML and your MFA
  37. 37You patched your Cisco email gateway. One email can still take it over.
all learning tracks →
BELOW 17.3 LTS ai_query returns anerror Nightly job fails 15.4 LTS stillsupported 17.3 LTS AND ABOVE AI Functions keepworking Spark 4 and Scala2.13 Test before youswitch
AI and data · 14 minYour Databricks AI Functions need Runtime 17.3 LTS by January 2027, even if 15.4 is still supported

Same SQL, same ai_query call. The runtime decides whether it still runs.

read next
keep reading

More field notes

Other notes from the same practices, newest first.

next step

Tell us what you're running. We'll tell you what we'd do first.

A 30-minute working session with a senior engineer. No slides.

useful to bring
  • The platform and the version you're on
  • Where you need to get to, and by when
  • What's custom: rules, plugins, integrations
  • Any audit finding or deadline driving it