Spring ‘26 leaves every connected app you have running and stops you from creating another. The outage risk is in the migration that follows, which teams will run on their own schedule.
The restriction applies in the UI and through the API, and getting it lifted means a case with Salesforce Support. Packaged apps keep working too, and the recommended home for anything new is an external client app. What changes is that the old model is now a place you can’t add to, and most teams will decide, reasonably, to move off it.
I think that’s the right call, and I’d start now while it’s still optional. I’d also treat it as a cutover with real outage risk, because that’s what it is.
What does not come with you
A new external client app is a new OAuth client. That has three consequences, and none of them show up in a sandbox smoke test with one user.
It has a new consumer key and secret. Every caller that holds the old pair needs a config change and a deploy.
Authorizations belong to the app. A user who approved the old app hasn’t approved the new one. For a server job that means pre-authorizing the integration user on the new app. For an app with human users it means every one of them goes through the consent screen again.
Refresh tokens don’t carry over. A token issued to the old app can’t be exchanged through the new one. The first call after the switch has to start from a fresh grant.
So the dangerous moment is the switch itself, per caller. Plan around that and the rest is paperwork.
Sort the inventory by OAuth flow
List every connected app, then classify each by the flow its callers use, because the flow decides the work.
- JWT bearer jobs are the easy ones. Upload the certificate to the new app, pre-authorize the integration user, swap the consumer key in the job’s config. No human involved.
- Client credentials is nearly as easy: set the run-as user on the new app, then swap key and secret.
- Web server flow with refresh tokens means users authorize again. There’s almost no code in it. The work is communication and timing.
- Username-password callers can’t move as they are, because external client apps don’t offer that flow at all. They need a rewrite first, usually to JWT bearer, so start with them. I covered the flows that work without a person in an earlier post on server-to-server OAuth.
Two queries tell you who is calling what. Logins by application over the last 90 days:
SELECT Application, LoginType, COUNT(Id) logins, MAX(LoginTime) lastLogin
FROM LoginHistory
WHERE LoginTime = LAST_N_DAYS:90
GROUP BY Application, LoginType
ORDER BY COUNT(Id) DESC
And tokens per app, with last-used date and use count:
SELECT AppName, UserId, UseCount, LastUsedDate, CreatedDate
FROM OauthToken
ORDER BY AppName, LastUsedDate DESC
Run both. Login history only reaches back about six months, and a flow that never issues a refresh token may leave nothing in the token list. Neither one alone is proof that an app is dead.
One flag per integration, both apps live
Create the new app next to the old one and leave the old one alone. Then give each integration a config flag that picks which app it authenticates with: old key or new key. An environment variable is enough.
Flip one caller, watch its next run succeed on the new app, move to the next. If the run fails, flip back. The old app is still there, still authorized, and the rollback takes a minute.
This is why I wouldn’t delete anything early, and why I wouldn’t do a single big switch over a weekend. Two apps running in parallel cost nothing. A failed switch with no way back costs a night.
When the old app can go
The rule I’d hold to: block the old app first, and delete it only after its last call is older than that integration’s longest gap between runs plus a week. Nothing gets deleted in under two weeks, however often it runs.
The gap is where people guess. A nightly job proves itself in a day. A month-end job needs a month. A quarterly export needs a full quarter before you know the new path works and nothing else was quietly riding on the old key. Blocking before deleting matters too, because a block is reversible and a delete is not.
Fourteen apps at Brindle Lift Services
Brindle Lift Services is my own invention, an elevator-maintenance company with 14 connected apps. Six are nightly jobs on JWT bearer, three are web-server apps with refresh tokens, two are client-credentials services, two are username-password scripts, and one hasn’t been called in a year.
The worksheet has one row per integration. Days count from the start of the project. Here are five of the fourteen rows:
| Integration | Owner | OAuth flow | Longest gap | New app name | Flag state | First success on new app | Last call on old app | Earliest delete |
|---|---|---|---|---|---|---|---|---|
| Parts inventory sync | Data eng | JWT bearer | 1 day | ecaPartsSync | new | Day 9 | Day 8 | Day 22 |
| Legacy pricing script | Finance ops | Username-password, rewritten to JWT bearer | 7 days | ecaPricingLoad | new | Day 6 | Day 5 | Day 19 |
| Technician tablet app | Field apps | Web server + refresh token | 14 days | ecaFieldTablet | new, 3 waves | Day 15 | Day 29 | Day 50 |
| Quarterly rebate export | Finance ops | Client credentials | 91 days | ecaRebateExport | new | Day 20 | Day 12 | Day 120 |
| Old survey connector | Nobody | Unknown | None in 12 months | not migrated | blocked | n/a | Over a year ago | Day 30 |
The two password scripts go first, since they need code. The tablet app’s 240 technicians authorize again in three regional waves across two weeks, so a bad consent screen strands one region’s morning and not the whole field force. The rebate export runs every 91 days. Its last real run on the old app was day 12, the day 20 success is a forced test run, and the next scheduled run isn’t until day 103. So its old app stays for 100 days after the flag flips, until a real quarterly run has gone through the new one and long after everyone has stopped thinking about the project. The unused app is blocked on day one and deleted after 30 quiet days, on the theory that if anyone was going to complain, they’d have done it by then.
In this version of events the active cutover takes five weeks with no failed runs. The deletes trail on for another three months. I’d put that tail on a calendar, because by then the person who knew why the old app was still around has moved on to something else.