Salesforce Winter '27 for Developers: What Changes Before Your Production Upgrade

Winter '27 (API version 68.0) has been in preview sandboxes since late August, and the last production upgrade weekends are almost here: Salesforce Trust lists 3, 9 and 10 October 2026 as the remaining dates, assigned by instance. If your org hasn't been upgraded yet, this is the week to check what changes for your code.

This post covers the developer-facing changes that matter most, what state each one is in (GA, beta or developer preview), and what to test before your org flips over.

Check your date first. Open Salesforce Trust, find your instance (Setup → Company Information), and look at its maintenance calendar. Preview sandboxes are already on Winter '27; production orgs on the later weekends are not.

At a glance

1. Apex heap limits go up — with a safety switch

The synchronous heap limit rises from 6 MB to 10 MB and the asynchronous limit from 12 MB to 25 MB. That is a big deal for anything that deserializes large JSON payloads, builds big maps in batch execute() methods, or assembles documents in memory.

The catch is timing. Your preview sandbox already has the higher limit; a production org on a later weekend does not. Code that passes in the sandbox with 8 MB of heap will fail in production until the upgrade lands. Salesforce added a setting, "Enforce the Summer '26 Apex heap limit", so you can keep sandbox behaviour aligned with production while you develop. Turn it on in the sandbox until production is upgraded, then turn it off.

Don't hard-code the number. Read it at run time:

Integer used    = Limits.getHeapSize();
Integer maxHeap = Limits.getLimitHeapSize();
if (used > maxHeap * 0.8) {
    // flush, chunk, or hand off to Queueable before hitting the wall
}

What to do: don't delete your chunking logic because the ceiling moved. Treat the extra headroom as margin, not as the new budget.

2. Apex integration tests can make real HTTP callouts (developer preview)

Mocks prove your code handles the response you expect. They don't catch the day the external API changes its payload. Winter '27 adds integration tests that call the real endpoint:

• Enable the ApexIntegrationTests feature in your scratch org definition file.
• Mark the class and each test method with @IntegrationTest.
• Integration tests don't roll back automatically. Use @BeforeClass to create shared data and @TearDown to clean up what you committed.
• They run asynchronously only, and only one at a time per org.

What to do: this is scratch-org-only developer preview, so keep your HttpCalloutMock tests; they're still what deploys to production. Use integration tests as a contract check in CI for your most fragile integrations.

3. The Apex Symbol API (beta)

A new Tooling API REST resource returns compiler-resolved metadata about Apex types: classes, methods, signatures. Until now you had to stitch this together from the /completions endpoint, the SymbolTable Tooling object and your own parser.

Salesforce's stated use cases are IDE code completion and grounding AI coding assistants so they stop inventing methods your org doesn't have. If your team is building internal tooling, linters or agents around your codebase, this is the source of truth to build on. It's beta, so don't make production processes depend on it yet.

4. LWC: complex template expressions are GA

After a beta in Spring '26, LWC templates can now use a broad subset of JavaScript expressions directly, not just property references. That removes a whole class of "formatting getters", and it fixes the old problem inside for:each loops, where a getter can't know which item it's being called for:

<template for:each={lines} for:item="line">
    <li key={line.id} class={line.overdue ? 'slds-text-color_error' : ''}>
        {line.name}: {line.qty * line.unitPrice}
    </li>
</template>

It only applies to components at API version 66.0 or later, set in each component's .js-meta.xml. Nothing changes for existing components until you bump them:

<apiVersion>66.0</apiVersion>

What to do: bump components one at a time and re-test them. Keep business logic in JavaScript; the template is for presentation.

5. LWC: third-party web components with lwc:external (GA)

Add lwc:external to a custom element in your template and LWC will render a standard third-party web component instead of treating it as an LWC:

<chart-widget lwc:external></chart-widget>

This replaces the old options of an iframe, a hand-maintained static-resource wrapper, or a full rewrite. Load the library the same way you do today; lwc:external only changes how the template treats the element.

6. SOQL: compare fields with FORMULA() (beta)

You can now compare two fields in a WHERE clause without creating a formula field just for filtering:

SELECT Id, Name
FROM Opportunity
WHERE FORMULA('Amount_To_Pay__c - Amount_Paid__c') > 0

It's beta, requires API 68.0, and isn't available in production orgs yet. Try it in a sandbox, but keep the formula-field or Apex-filter approach in anything you ship.

7. REST API: latest instead of a version number

You can now call /services/data/latest/… instead of pinning v66.0, v67.0 and so on:

https://<MyDomainName>.my.salesforce.com/services/data/latest/sobjects/Account

This is handy for scripts and admin tools. For production integrations, think before you switch: pinning a version is what protects you from behaviour changes three times a year. A good compromise is latest in internal tooling and a pinned version, reviewed each release, in customer-facing integrations.

8. Managed packages: no more field-name shadowing in dynamic SOQL

ISVs have long had to worry about a subscriber's custom field having the same API name as a package field. Set the explicitNamespace property on a Database.QueryOptions object and your dynamic query resolves to your namespace's field. The release notes include sample code.

9. Recompile only invalid Apex

Large orgs can now recompile just the invalid classes and triggers instead of everything. That makes it practical to fix invalid code after a big metadata deploy without a long "compile all" run.

Release updates to check before the upgrade

These are the enforced changes most likely to cause "it worked on Friday" tickets:

1. SOAP API login() needs the "Use Any API Auth" permission. Integration users without it can no longer authenticate with SOAP login(). Find every integration that still logs in with username + password + token over SOAP (older ETL tools, middleware, desktop data loaders), then either assign the permission or, better, move it to OAuth.
2. Profile Filtering is enabled by default. Users can only see the name of their own profile unless they have View All Profiles. Check custom UIs, reports and Apex that display or filter on other users' profile names.
3. Accessibility release updates change the layout of cards, docked containers, menu lists, panels, date pickers, popovers, utility bars, record headers, page headers and modals at zoom levels above 200%. If you have UI tests that assert on layout or DOM position, run them against a Winter '27 sandbox.

A 30-minute pre-upgrade checklist

• Confirm your production upgrade date on Trust.
• In the preview sandbox, run all local tests and your UI smoke tests.
• Grep for SOAP login() usage and list the integration users; check their permissions.
• Search for code or reports that read other users' Profile.Name.
• If you're developing on Winter '27 but deploying before your upgrade, turn on "Enforce the Summer '26 Apex heap limit".
• Review Setup → Release Updates for anything with an enforcement date this release.

Upgraded already and something broke? We'll cover the most common post-upgrade issues and their fixes in an upcoming post. If you need help now, talk to us.

Sources

• Top 10 Salesforce Winter '27 Features for Developers: Salesforce Ben, updated 15 Sep 2026
• Salesforce Winter '27 Release: Everything You Need to Know Before Go-Live: Salesforce Ben, 14 Sep 2026
• Salesforce Winter '27 Release Date + Preview Information: Salesforce Ben
• Winter '27 Release Notes: Salesforce Help
• Release notes: Apex heap limit, Apex integration tests, Apex Symbol API, LWC complex template expressions, Third-party web components, SOQL FORMULA(), REST latest, Namespace shadowing in managed packages, Recompile invalid Apex
• Release updates: SOAP login() and Use Any API Auth, Profile Filtering, Accessibility: page headers and modals
• Salesforce Trust: maintenance calendar by instance