Release guide

Salesforce Winter '27: What Actually Changes for Apex Developers

Published September 5, 2026 — updated as Winter '27 moves from preview toward general availability.

Winter '27 is Salesforce's next major platform release, and as of this writing it's in preview — live in sandboxes and scratch orgs, not yet generally available in production. The full list runs to hundreds of items across every cloud; this is the part that actually touches Apex, SOQL, and Lightning Web Components, filtered down to what's worth changing your code for. For the complete, authoritative list, see the official Winter '27 release notes.

Heap limits just got a lot bigger

Synchronous Apex transactions go from a 6 MB heap to 10 MB; asynchronous transactions (batch, queueable, future methods) go from 12 MB to 25 MB. That's the ceiling that's been quietly forcing developers to chunk large collections or process records in smaller batches for years. If you've got a batch job whose scope size was tuned around hitting that old limit, Winter '27 is a good excuse to revisit it — check current usage with Limits.getLimitHeapSize() before you assume you need the extra room. The Batch Apex generator already writes governor-aware chunking; bigger heap just means fewer transactions hitting the wall in the first place.

FORMULA() lands in SOQL — but only in sandboxes for now

You can now do arithmetic directly in a SOQL WHERE clause instead of creating a formula field just to filter on it — for example, WHERE FORMULA('Amount_To_Pay__c - Amount_Paid__c') > 0. It's beta, requires API version 68.0 or later, and Salesforce has it scoped to sandbox, Developer Edition, and scratch orgs only — not production. Worth prototyping now precisely because it isn't production-safe yet; you'll want to know how it behaves before it's an option your team reaches for under deadline. The SOQL query generator can already target API 68.0 conventions if you mention it in your prompt's org context.

Apex integration tests can call real endpoints

A new developer-preview annotation, @IntegrationTest, lets a test method make an actual HTTP callout instead of a mocked one — currently scoped to Agentforce and Data 360 services. It runs asynchronously and only one at a time per org, so it's not a replacement for your existing HttpCalloutMock coverage, but it closes a real gap: today, "the mock says it works" and "the real endpoint says it works" can quietly diverge. Worth knowing about even before you have a use for it.

The Apex Symbol API — mostly relevant if you build tooling

A new Tooling API REST resource returns compiler-grade metadata about your org's Apex types — the same kind of information an IDE's autocomplete or an AI coding assistant needs to ground its suggestions in what your org actually contains, rather than guessing. Most developers won't call it directly, but it's a sign of where the platform is investing: org-aware tooling is becoming a first-class API, not a scraped side effect.

Smaller wins worth knowing about

Selective recompilation — Salesforce can now recompile only the Apex classes and triggers that are actually invalid, instead of the whole set, which should speed up deploys on larger orgs.
explicitNamespace on Database.QueryOptions — fixes the long-standing annoyance where a managed package field and a subscriber-org field with the same API name get treated as one and the same in a query.
latest as a REST API version — /services/data/latest/sobjects/Account always routes to the newest supported version, so integrations stop needing a version-bump commit every release.

For Lightning Web Components

Complex template expressions are now generally available at API version 66.0+ — real JavaScript expressions directly in your markup, which cuts down on writing a getter purely to compute something the template could just do inline. Separately, the lwc:external directive lets you drop in a genuine third-party web component without the iframe workaround that's been the usual escape hatch. If you're building the UI layer of a feature, the Lightning Web Component generator is worth revisiting with API 66.0+ in mind.

How to actually prepare

Since this is all still preview, none of it needs a production decision today — but sandbox testing now is exactly how you avoid finding out the hard way in three months. A reasonable checklist: bump a sandbox to API 68.0 and try FORMULA() against a real query you already have; check whether any batch job's scope size was quietly tuned around the old heap ceiling; and if you're maintaining LWCs with awkward computed getters, see how much a complex template expression actually simplifies. None of this requires rewriting anything today — it's reconnaissance, not migration.

If you're scoping a new feature that touches several of these at once — a bigger batch job, a component that needs the new template syntax, a permission set to go with it — the Build tab plans the whole thing in one pass instead of one file at a time.