Salesforce Spring ’26 Release: What Developers Need to Know

The Salesforce Spring ’26 release is packed with developer-focused enhancements that touch every layer of the platform — from Lightning Web Components and Apex to the rapidly evolving Agentforce ecosystem. Whether you’re building custom UIs, optimizing backend logic, or experimenting with AI-powered agents, this release introduces capabilities that will meaningfully change how you write, test, and deploy Salesforce code. In this post, we break down the most important updates, explain why they matter, and give you practical code examples you can start using today.

Lightning Web Components (LWC): More Power, Less Boilerplate

Dynamic Event Listeners with `lwc:on`

One of the most requested LWC features has finally arrived. The new lwc:on directive lets you attach event listeners dynamically at runtime using a JavaScript object, rather than hardcoding them in your template. This is a game-changer for building reusable, configurable components where event behavior needs to vary based on context or configuration data.

Best Practice Tip: Use lwc:on to build a single generic table or card component that handles different action sets depending on where it’s rendered — reducing the number of near-identical components in your org.

// dynamicEventDemo.js
import { LightningElement, track } from 'lwc';

export default class DynamicEventDemo extends LightningElement {
    @track message = '';

    // Build an event handler map dynamically at runtime
    get eventHandlers() {
        return {
            // Attach a 'select' handler only when the component is in "edit" mode
            select: this.handleSelect.bind(this),
            highlight: this.handleHighlight.bind(this)
        };
    }

    handleSelect(event) {
        this.message = `Item selected: ${event.detail.label}`;
    }

    handleHighlight(event) {
        this.message = `Item highlighted: ${event.detail.label}`;
    }
}


<template>
    <!-- lwc:on binds the handler map object to this child component -->
    <c-item-list lwc:on={eventHandlers}></c-item-list>
    <p>{message}</p>
</template>

GraphQL Mutations with `executeMutation`

The lightning/graphql module now exposes an imperative executeMutation method, complementing the existing reactive @wire(graphql) adapter. This means you can now create, update, and delete records directly from JavaScript using GraphQL — giving you a modern, flexible alternative to lightning/uiRecordApi for complex data operations.

Best Practice Tip: Prefer executeMutation over multiple chained updateRecord wire calls when you need to modify related records in a single, readable operation.

// graphqlMutationDemo.js
import { LightningElement } from 'lwc';
import { executeMutation, gql } from 'lightning/graphql';

const UPDATE_ACCOUNT = gql`
    mutation UpdateAccountName($accountId: ID!, $newName: String!) {
        uiRecordApi {
            updateRecord(input: {
                fields: { Id: $accountId, Name: $newName }
            }) {
                record {
                    Id
                    Name { value }
                }
            }
        }
    }
`;

export default class GraphqlMutationDemo extends LightningElement {
    accountId = '001XXXXXXXXXXXXXXX';

    async handleUpdateName() {
        try {
            // Imperatively execute the mutation with variables
            const result = await executeMutation(this, {
                mutation: UPDATE_ACCOUNT,
                variables: {
                    accountId: this.accountId,
                    newName: 'Acme Corp (Updated)'
                }
            });
            console.log('Updated:', result.data.uiRecordApi.updateRecord.record);
        } catch (error) {
            console.error('Mutation failed:', error);
        }
    }
}

Complex Template Expressions (Beta)

Say goodbye to boilerplate getter methods for simple display logic. Spring ’26 allows you to write JavaScript expressions — including template literals, ternary operators, optional chaining, null coalescing, and array methods — directly inside your HTML templates. This keeps your component JavaScript clean and your templates self-documenting.

Best Practice Tip: Reserve complex template expressions for truly simple display logic. If your expression is hard to read inline, move it to a getter to preserve readability and testability.


<template>
    <!-- Ternary operator directly in template -->
    <p>Status: {record.isActive ? 'Active' : 'Inactive'}</p>

    <!-- Optional chaining with null coalescing -->
    <p>Owner: {record?.owner?.Name ?? 'Unassigned'}</p>

    <!-- Template literal for formatted output -->
    <p>{`Welcome back, ${record?.owner?.FirstName}!`}</p>

    <!-- Array method to count active items -->
    <p>Active Items: {items.filter(i => i.isActive).length}</p>
</template>

Apex: Performance, Productivity, and AI Integration

Apex Cursors (Generally Available)

Apex Cursors graduate to GA in Spring ’26, and they’re one of the most significant additions to Apex in years. Cursors let you work through large SOQL result sets in manageable chunks, with support for bidirectional traversal. Unlike Batch Apex, which imposes significant structural overhead, cursors are lightweight and composable. They can also be serialized across Queueable chains — and exposed via @AuraEnabled for LWC integration.

Best Practice Tip: Use Apex Cursors when you need to process large datasets within a single transaction context or across a Queueable chain, reserving Batch Apex for operations that genuinely require parallel execution across many transactions.

// AccountCursorProcessor.cls
public class AccountCursorProcessor implements Queueable {

    private ApexCursor cursor;
    private static final Integer CHUNK_SIZE = 200;

    public AccountCursorProcessor() {
        // Initialize cursor with a SOQL query on a large dataset
        this.cursor = Database.getCursor(
            'SELECT Id, Name, AnnualRevenue FROM Account WHERE AnnualRevenue != null ORDER BY AnnualRevenue DESC'
        );
    }

    // Constructor for chained queueable jobs with existing cursor
    public AccountCursorProcessor(ApexCursor cursor) {
        this.cursor = cursor;
    }

    public void execute(QueueableContext ctx) {
        // Fetch the next chunk of records from the cursor
        List<Account> accounts = (List<Account>) cursor.fetch(Account.class, CHUNK_SIZE);

        if (!accounts.isEmpty()) {
            // Process this chunk — e.g., apply revenue tier categorization
            for (Account acc : accounts) {
                acc.Description = acc.AnnualRevenue > 1000000 ? 'Enterprise' : 'SMB';
            }
            update accounts;

            // If more records remain, enqueue next job with the same cursor
            if (!cursor.isFullyConsumed()) {
                System.enqueueJob(new AccountCursorProcessor(cursor));
            }
        }
    }
}

Faster Deployments with `RunRelevantTests` (Beta)

Deployment speed has long been a pain point for Salesforce teams. The new RunRelevantTests test level automatically analyzes your code changes and runs only the tests that are relevant to what you’ve modified. Pair this with the new @IsTest(critical=true) and @IsTest(testFor='ApexClass:MyClass') annotations to give the platform better signals about test priority and coverage mapping.

Best Practice Tip: Start annotating your existing test classes with @IsTest(testFor=...) now, even before you use RunRelevantTests, so your org builds a reliable coverage map ahead of GA.

// AccountServiceTest.cls
@IsTest(testFor='ApexClass:AccountService') // Links this test to its target class
public class AccountServiceTest {

    @IsTest(critical=true) // Marks this as a high-priority test — always run
    static void testCreateAccount_withValidData_succeeds() {
        Test.startTest();
        Account result = AccountService.createAccount('Spring Test Corp', 'Technology');
        Test.stopTest();

        System.assertNotEquals(null, result.Id, 'Account should have been inserted successfully.');
        System.assertEquals('Technology', result.Industry, 'Industry should match the input value.');
    }

    @IsTest
    static void testCreateAccount_withMissingName_throwsException() {
        Test.startTest();
        try {
            AccountService.createAccount(null, 'Technology');
            System.assert(false, 'Expected exception was not thrown.');
        } catch (AccountService.AccountCreationException e) {
            System.assert(e.getMessage().contains('Name'), 'Exception should reference the Name field.');
        }
        Test.stopTest();
    }
}

Agent Actions from Apex

Spring ’26 makes it straightforward to expose Apex methods as Agentforce agent actions. By adding the appropriate annotations to your Apex class methods, Salesforce automatically generates the OpenAPI specification required for the agent to understand and invoke your action. This dramatically lowers the barrier to extending Agentforce with custom business logic.

Best Practice Tip: Write your agent action methods to be stateless and idempotent where possible — agents may retry actions, and predictable behavior is critical for reliable AI workflows.

// OrderLookupAction.cls
public class OrderLookupAction {

    // Annotate the method to expose it as an Agentforce agent action
    @AgentAction(
        label='Get Recent Orders for Account',
        description='Returns the 5 most recent orders for a given account ID, including status and total amount.'
    )
    public static List<OrderSummary> getRecentOrders(String accountId) {
        List<Order> orders = [
            SELECT Id, OrderNumber, Status, TotalAmount
            FROM Order
            WHERE AccountId = :accountId
            ORDER BY CreatedDate DESC
            LIMIT 5
        ];

        // Map to a clean output type for the agent to consume
        List<OrderSummary> summaries = new List<OrderSummary>();
        for (Order o : orders) {
            OrderSummary s = new OrderSummary();
            s.orderNumber = o.OrderNumber;
            s.status = o.Status;
            s.totalAmount = o.TotalAmount;
            summaries.add(s);
        }
        return summaries;
    }

    public class OrderSummary {
        @AuraEnabled public String orderNumber;
        @AuraEnabled public String status;
        @AuraEnabled public Decimal totalAmount;
    }
}

Agentforce: Pro-Code Tools for AI Development

Agentforce DX and Agent Script (Beta)

Spring ’26 signals Salesforce’s commitment to making Agentforce a first-class development experience. Agentforce DX brings agent development into VS Code and the Salesforce CLI, complete with syntax highlighting for the new Agent Script language, live and simulated previews, and auto-approval for read-only MCP tools. Agent Script itself is a hybrid language that lets you mix natural language instructions with strict programmatic control flow — think if-else conditions and sequential action chaining — giving you the best of both AI flexibility and deterministic logic.

Best Practice Tip: Use Agent Script’s strict conditional blocks for any agent behavior that has compliance, financial, or data-sensitivity implications. Reserve natural language instructions for conversational framing and user-facing communication.

// Example: Agent Script snippet (conceptual representation)
// This illustrates mixing natural language with strict control flow

AGENT: CustomerSupportAgent

// Natural language instruction for greeting
INSTRUCT: Greet the customer warmly and ask how you can help them today.

// Strict conditional logic for routing
IF customer.caseCount > 5 AND customer.tier == "Enterprise" THEN
    ACTION: escalate_to_senior_support(customerId: customer.id)
    INSTRUCT: Inform the customer that a senior specialist will be in touch within 1 hour.
ELSE IF customer.openCaseCount > 0 THEN
    ACTION: get_open_cases(customerId: customer.id)
    INSTRUCT: Summarize the open cases and ask the customer which one they need help with.
ELSE
    INSTRUCT: Ask the customer to describe their issue so you can create a new support case.
END IF

The new Agent Grid (Beta) complements this by providing a spreadsheet-like testing environment where you can rapidly iterate on AI workflows using real CRM data — making it far faster to validate agent behavior before deploying to production.

APIs & Platform Tools: Critical Changes to Act On Now

Session ID Removal — Action Required

This is the most urgent item in the Spring ’26 release for any team using outbound messaging. Effective February 16, 2026, Salesforce will stop sending session IDs in outbound messages. If your integrations rely on session IDs for authentication, they will break. You must migrate to OAuth-based authentication before this date.

Best Practice Tip: Audit your outbound message configurations and connected middleware immediately. Prioritize any flows that handle financial transactions, data synchronization, or customer-facing updates.

Named Query API (GA)

The Named Query API is now generally available, letting you define custom SOQL queries as named, reusable API endpoints. This is ideal for exposing optimized, permission-controlled data access to external systems without building and maintaining custom REST resources for every use case.

Connected Apps Restriction

New Connected Apps can no longer be created by default. Salesforce is steering developers toward External Client Apps for new integrations. If you’re starting a new integration project in Spring ’26 or later, plan to use External Client Apps from day one rather than migrating later.

Salesforce CLI Enhancements

The CLI gets meaningful quality-of-life improvements: Unified Logic Testing (Beta) lets you run Apex and Flow tests simultaneously in a single command, streamlining CI/CD pipelines. You can also retrieve package source for 2GP and unlocked packages, and customize login timeouts and test polling intervals — useful for teams working with slower network environments or large test suites.