Every Salesforce release cycle brings a wave of release notes, blog posts, and Trailhead modules all competing for your attention. I’ve been going through Spring ‘26 in detail for the past few weeks, and I want to save you some time. These 15 features represent the most impactful changes across the platform — the ones that will directly affect how you build, deploy, and maintain your orgs.
Let me walk you through each one with context on why it matters.
Feature Highlights at a Glance
Flows: Four Features That Change Everything
1. Reactive Screen Components
This is the one I’ve been waiting for since Screen Flows were introduced. Reactive screen components allow components within the same screen to dynamically respond to each other’s values — without leaving the screen. Previously, you had to split logic across multiple screens or resort to custom LWC components to achieve this kind of interactivity.
Now, you can bind a screen component’s input to another component’s output directly on the canvas. As the user types into a search field, a dependent picklist on the same screen updates its values in real time. This works with both standard screen components and custom LWC screen components that have opted in.
To opt a custom component in, you add @api reactive properties and declare them in the component’s .js-meta.xml. The Flow runtime handles the change propagation.
2. Collection Operators: Filter, Sort, Map in Flow
Before Spring ‘26, doing anything non-trivial with a collection in Flow meant either looping with assignment elements (verbose and slow) or calling an Apex method. The new collection operators bring three new elements to the Flow canvas:
- Collection Filter: Filter a collection of records or variables using conditions similar to SOQL WHERE clauses
- Collection Sort: Sort a collection by one or more fields, ascending or descending
- Collection Map: Transform a collection by extracting a specific field into a new collection
These three operators alone eliminate a large category of “I had to write Apex for this” Flow patterns. If you’ve been building invocable Apex methods just to filter or sort collections, those can now be replaced declaratively.
3. Improved Loop Performance
Salesforce has refactored the internal execution of Loop elements. In previous releases, deeply nested loops or loops over large collections could hit governor limit issues or cause slow screen transitions. Spring ‘26 introduces lazy evaluation and improved iteration tracking that significantly reduces loop overhead for collections under 50,000 records.
4. Scheduled Path Enhancements
Scheduled paths now support dynamic offset fields. Instead of hardcoding “3 days after CreatedDate”, you can reference a field on the record — for example, {!Record.SLA_Due_Date__c} - 1 day. This opens up SLA-driven automation patterns that previously required Apex-scheduled classes.
LWC: The Future Is Reactive
5. LWC Signals (Developer Preview)
Signals bring a fine-grained reactivity model to LWC, inspired by frameworks like Preact Signals and SolidJS. Instead of relying on property reassignment to trigger re-renders, a Signal is an observable value that components subscribe to.
import { signal, computed } from 'lwc';
export default class MyComponent extends LightningElement {
count = signal(0);
doubled = computed(() => this.count.value * 2);
increment() {
this.count.value++;
}
}Only the parts of the template that actually read the signal re-render when it changes. This is a preview feature, not yet production-ready, but it is the direction LWC is heading.
LWC Signals is a developer preview only. Do not use in production yet. Monitor the feature roadmap for GA announcement.
6. Dynamic Imports in LWC
LWC now supports dynamic import() syntax for lazy-loading modules. This is significant for complex components that load expensive dependencies (charts, PDF libraries, etc.) only when needed:
async handleChartClick() {
const { default: ChartLib } = await import('c/heavyChartLibrary');
this.chart = new ChartLib(this.template.querySelector('.chart-container'));
}This reduces initial bundle size and improves page load performance for feature-rich UIs.
7. Wire Service Caching Improvements
The wire service now has a configurable cache TTL per adapter. Custom Apex wire adapters can declare their cache duration, and the LWC runtime respects this when deciding whether to serve from cache or re-fetch. This reduces redundant server calls on pages with multiple components wiring to the same data.
8. Named Slot Enhancements
Named slots in LWC now support fallback content — content that renders when no slot content is provided by the parent. This is consistent with how the Web Components spec works and reduces the boilerplate of conditional rendering in wrapper components.
DevOps Center: General Availability
9. DevOps Center GA
DevOps Center exits beta and reaches General Availability in Spring ‘26. The GA release includes the pipeline automation features that were the most-requested additions during beta: automated promotion rules that can trigger when a pipeline stage is complete, integration with Salesforce CLI for headless operations, and improved handling of destructive changes.
10. Built-In Conflict Resolution
The GA version includes a visual conflict resolution tool. When two pipeline stages have diverging changes to the same metadata component, DevOps Center presents a side-by-side diff and allows you to choose which version wins — or manually merge them — directly in the browser. This is a major usability improvement over the previous workflow of resolving conflicts in a code editor.
11. Scratch Org Pooling (Beta)
Scratch Org Pooling Details
Scratch Org Pools allow you to pre-create a set of ready-to-use scratch orgs with your package dependencies already installed. Developers claim an org from the pool rather than waiting for a fresh org to spin up and install. Org creation time drops from 10-15 minutes to near-instant.
This is especially valuable for large teams where scratch org creation is the bottleneck in the developer workflow. The pool manager handles lifecycle, recycling, and dependency updates automatically.
Admin and Platform
12. Dynamic Forms: General Availability for All Standard Objects
Dynamic Forms — which let you place individual fields and sections anywhere on a Lightning record page instead of being locked to the page layout — is now GA for all standard objects. Previously it was GA only for custom objects and a subset of standard objects. This is one of the most impactful admin features in years because it finally decouples field placement from page layouts for the entire object model.
When migrating to Dynamic Forms GA for standard objects, start with objects that have the most complex page layouts with many conditionally visible fields. Dynamic Forms’ field-level visibility rules replace the need for multiple page layouts, immediately reducing the layout maintenance burden without changing any automation.
13. Apex Null Safety Operator
Apex now supports the null-safe navigation operator ?. for chained property access. This has been a feature request for years:
// Before — verbose defensive coding
String city = account != null && account.BillingAddress != null
? account.BillingAddress.city
: null;
// After Spring '26 — clean and concise
String city = account?.BillingAddress?.city;This significantly cleans up defensive Apex code and reduces the boilerplate of null checks in deep object traversal.
14. Record Alerts: General Availability
Record Alerts — the ability to display dynamic banners and indicators on record pages based on criteria you define — reached GA. Admins can configure alerts through the UI without code, and developers can create custom alert badges via Apex. Use cases include: escalated case warnings, overdue payment flags, compliance holds, and data quality indicators.
15. In-App Guidance Enhancements
In-App Guidance now supports multi-step walkthroughs that can branch based on user role or profile. Combined with the ability to trigger guidance from a Flow, this makes onboarding automation and feature adoption campaigns significantly more sophisticated without needing third-party tools.
How to Prioritize These Features
My recommended order for most orgs:
- Start immediately: Dynamic Forms GA, Apex null safety operator, Collection operators in Flow
- Plan for next sprint: Reactive screen components, scheduled path dynamic offsets
- Evaluate for your context: DevOps Center GA (if you’re not already on a mature CI/CD pipeline), scratch org pooling
- Monitor: LWC Signals (preview only — don’t use in production yet)
Problem: Your Flow-based lead nurture sequence sends follow-up emails using a Loop with multiple Assignment elements to collect records, then an individual Send Email action inside the loop body — and you are hitting the 10-single-email-per-transaction limit via Messaging.sendEmail() on large batches.
Solution (Spring ‘26): Replace the loop-and-filter pattern with the new Collection Filter operator to isolate records that need emails in a single step, then use a bulk Send Email action outside the loop. Collection operators remove the need for looping in many cases entirely, keeping you well within transaction limits.
What I’m Most Excited About
The combination of Dynamic Forms GA and Collection Operators in Flow is the most impactful pairing in this release for the broadest audience. Dynamic Forms removes one of the oldest pain points in Lightning App Builder work, and Collection Operators eliminate a huge category of “I need an Apex class for this” Flow patterns.
For developers specifically, Apex null safety is the quality-of-life improvement that will quietly save hours of debugging every month.
Which of these 15 features are you planning to use first in your org, and is there anything from Spring ‘26 that you think deserves more attention than it’s getting?
How did this article make you feel?
Comments
Salesforce Tip