Salesforce Winter ’27: 8 Developer Updates You Should Know

1. Higher Apex Heap Limits

One of the most useful developer-focused changes is the increase in Apex heap limits.

Salesforce is increasing the limits to:

That gives Apex more room to work with larger datasets and more complex processing without hitting heap-size exceptions.

For example, code that processes large collections, JSON responses, or complex data structures may have more headroom:

List<Account> accounts = [
    SELECT Id, Name, Description
    FROM Account
];

for (Account acc : accounts) {
    // Complex processing
}

Developer takeaway

This doesn’t mean we should stop thinking about heap usage.

Bulkification, selective SOQL, efficient collections, and avoiding unnecessary data loading still matter.

The higher limit gives you more room—it doesn’t eliminate governor limits.

2. Compare Fields Directly in SOQL with FORMULA()

This is one of the more interesting SOQL changes.

Salesforce is introducing FORMULA() support that allows developers to perform arithmetic calculations directly in a WHERE clause. The capability is currently Beta.

For example:

SELECT Id, Name, Revenue__c, Cost__c
FROM Opportunity
WHERE FORMULA('Revenue__c - Cost__c') > 10000

Instead of creating a dedicated formula field just for the comparison, the calculation can live inside the query.

Why is this useful?

Previously, you might have created:

Profit__c = Revenue__c - Cost__c

and then queried:

WHERE Profit__c > 10000

Or you might retrieve the records and perform the calculation in Apex.

FORMULA() provides another option.

Important

This is currently a Beta capability, so don’t treat it as a replacement for Salesforce’s complete Formula Engine. Salesforce documents specific supported arithmetic and expression behavior.

3. More Complex Template Expressions in LWC

Lightning Web Components continue to become more expressive.

Winter ’27 includes Complex Template Expressions in LWC as generally available.

This helps developers write cleaner template logic instead of moving every small piece of presentation logic into JavaScript.

Conceptually, this means templates can handle more sophisticated expressions when rendering UI.

That can make components easier to maintain when the UI depends on calculated or conditional values.

Developer takeaway

The goal isn’t to move all application logic into HTML.

Instead:

JavaScript → business logic

Template → presentation logic

The new capabilities give developers more flexibility while keeping simple UI conditions close to the template.

4. Apex Integration Tests Can Call Real HTTP Endpoints

This is potentially a big deal for integration-heavy Salesforce projects.

Winter ’27 introduces Apex Integration Tests that can call real HTTP endpoints without requiring traditional mock callouts. The feature is currently Developer Preview and is available for scratch orgs.

For example:

@IntegrationTest
public static void testExternalService() {

    HttpRequest request = new HttpRequest();

    request.setEndpoint(
        'callout:PaymentGateway/verify'
    );

    request.setMethod('GET');

    HttpResponse response =
        new Http().send(request);

    Assert.areEqual(
        200,
        response.getStatusCode()
    );
}

This allows developers to test the actual request/response interaction.

You can catch problems such as:

• Authentication failures
• Serialization issues
• Incorrect request payloads
• Timeout behavior
• Unexpected responses
• Integration configuration problems

These are issues that a traditional mock may never reveal.

Important

This is Developer Preview, so it shouldn’t be treated as production-ready functionality yet.

5. Use /latest in REST API URLs

Another useful API improvement is the ability to use:

/services/data/latest/

instead of specifying a numbered API version.

For example:

https://your-domain.my.salesforce.com/services/data/latest/sobjects/Account

Why does this matter?

Previously, developers commonly used:

/services/data/v68.0/

When the API version changed, integrations could require updates.

With:

/services/data/latest/

the endpoint can automatically target the newest API version supported by the org.

But be careful

For long-lived production integrations, automatically moving to a new API version isn’t always desirable.

If you need predictable behavior, explicitly versioning your API calls can still be the better strategy.

6. OAuth Username-Password Flow Is Being Retired

This is one developers and integration teams should not ignore.

Salesforce is retiring the OAuth 2.0 Username-Password Flow for Connected Apps.

The enforcement date is currently February 20, 2027. Salesforce changed this date from the original Winter ’27 enforcement schedule.

If your integration currently does something like:

Username
   +
Password
   ↓
OAuth Username-Password Flow
   ↓
Salesforce Access Token

you should start planning the migration.

Salesforce recommends more secure alternatives, including:

Web-server flow

For applications involving user authorization:

OAuth Web Server Flow
        +
PKCE

Client Credentials Flow

For appropriate server-to-server integrations:

Application
     ↓
Client Credentials
     ↓
Salesforce

Salesforce states that integrations using the retired flow will stop working when the update is enforced.

Developer action

Search your existing integrations for:

grant_type=password

Don’t wait until the enforcement date.

7. ApexGuru Can Detect Duplicate Apex Code

Winter ’27 also brings developer tooling improvements around ApexGuru.

ApexGuru can identify exact and near-duplicate Apex code in an org. Salesforce describes detection for code with 95% or greater similarity and can identify duplication at file, method, and block levels.

This is useful for large Salesforce orgs where the same logic has slowly been implemented multiple times.

For example:

OrderService.cls
    ↓
calculateDiscount()

QuoteService.cls
    ↓
calculateDiscount()

OpportunityService.cls
    ↓
calculateDiscount()

Instead of maintaining three versions of essentially the same logic, duplicate-code analysis can help identify candidates for refactoring.

Why developers should care

Duplicate code means:

• More maintenance
• More bugs
• More testing
• More technical debt
• More opportunities for inconsistent behavior

ApexGuru gives teams another way to identify these patterns.

8. More Developer Tooling and Platform Improvements

Winter ’27 also contains a broader collection of developer improvements.

Salesforce highlights enhancements around:

• Apex tooling
• Apex Symbol API
• API version 68.0
• Salesforce CLI
• Agentforce Vibes
• Salesforce Extensions for VS Code
• Apex recompilation
• Compiler warnings
• Managed-package development
• Developer tooling