Insights from Salesforce Spring 26 Certificate Maintenance

These are my quick notes from the Salesforce Spring 26 certificate maintenance modules. I grouped them by certification so it is easier to come back later and quickly remember what changed.

Platform Administrator

1. Request Approval Component

The new Request Approval component is a nice update because approval submission can now feel more native inside the page.

Key points:

• No need to create custom buttons just for submitting approvals.
• We can configure it so the submitter chooses the first approver.
• Comments can be shown or hidden while submitting.
• It works in Lightning pages and Experience sites.
• After placing the component, we need to choose the flow approval process it should use.

This feels useful when the approval action should sit directly on the page instead of being hidden behind a custom button or separate action.

2. Flow Component-Level Styling

Screen Flows now have more styling control at the component level, which is a small but useful improvement.

Steps:

1. Open a Screen Flow.
2. Select any screen.
3. Open the screen properties.
4. Go to the Style tab.
5. Configure styling for the screen elements.

This should help when a Flow screen needs a bit more polish without creating custom components for every small UI change.

3. Allow More Users to Delete Files

Salesforce now allows file deletion access to be handled more flexibly.

With the Delete Salesforce Files permission, users who are not System Administrators can also delete files that they can view.

This is handy when file cleanup should be handled by the users who actually work with the records, instead of always depending on a System Administrator.

Platform Developer 1

1. Salesforce External Services Can Handle Large Data

Salesforce External Services can now handle large data more efficiently.

Instead of loading large data directly into the Apex heap, Salesforce stores it in a ContentDocument and references it with a pointer.

That should reduce heap pressure when working with bigger payloads through External Services.

2. Access Modifiers Are Required on Abstract and Override Methods

From API 65.0, abstract and override methods must include access modifiers.

Earlier, code like this might have worked:

public abstract class PaymentProcessor {
    abstract void processPayment();
}

Now, the method needs an access modifier:

public abstract class PaymentProcessor {
    protected abstract void processPayment();
}

So the main thing to remember here is: do not leave abstract or override methods without visibility anymore. Make it explicit.

3. Third-Party Scripts with LWS Trusted Mode

Lightning Web Security usually prevents third-party scripts from directly touching browser APIs like the DOM, window, or global variables.

With LWS Trusted Mode, trusted scripts can run with access to APIs that are normally restricted.

This can help when a third-party JavaScript library needs deeper browser access, but it is definitely something to use carefully because the script gets more power inside the page.

4. New and Changed LWC Modules

lightning/graphql

Earlier, we commonly used:

import { gql, graphql } from 'lightning/uiGraphQLApi';

Now Salesforce recommends:

import { gql, graphql } from 'lightning/graphql';

lightning/omnistudioPubsub

This module helps custom components communicate with FlexCards or OmniScripts using a publish-subscribe mechanism.

lightning/conversationToolkitApi

This module lets us inactivate a conversation record from an LWC using the record Id.

5. LWC Components for Local Actions in Screen Flows

LWC can now be used for local actions inside Screen Flows using this target config:

<targetConfig targets="lightning__FlowAction">
</targetConfig>

This is useful for small client-side actions inside a Flow, like showing a toast, copying text, or doing quick UI-only actions.

CRM Analytics

Join Data Source in Lens

Inside a Lens, CRM Analytics now supports Join Data Source in beta.

You can choose join options such as:

This is useful when we want to compare datasets directly inside a Lens and quickly find matching or non-matching records.