Customers / Administrator’s Point of View

1. See Tenant IDs in the Your Account App: – Now you can see the ID of your Salesforce org, Tableau deployment, Mulesoft org, Commerce Cloud tenant, and your Marketing Cloud MID (Member ID) in the contracts area of the Your Account app. When you purchase a product, it’s assigned and provisioned to a specific tenant. Seeing tenant IDs in your contracts list helps you monitor license usage by tenant.
   1. Launch the Your Account app and select a contract from your contract list to view the details (1).
2. Undo Field Changes with a Click: –When you type in an input field on a Lightning Web Components record page, an undo button appears and the background color changes until you save. Clicking the undo button removes your unsaved changes. This functionality doesn’t occur in Dynamic Forms—enabled pages. Previously, to use the undo button, you clicked a field, entered content, and then clicked outside the field.
3. News, Automated Account Fields, and Account Logos Are Being Retired: – The News, automated account fields, and automated account logo features are being retired in all Salesforce orgs in Winter ’24 on October 13, 2023. After these account features are retired, Salesforce doesn’t prompt users with suggestions for account names and doesn’t fill out fields or add company logos automatically. The News component is removed from page layouts.
4. Allow Delegated Admins to Manage Permission Set Group Assignments: – Delegated administrators can now manage the assignment of permission set groups for users in their delegated group, giving you more time for other admin tasks.
   1. From Delegated Administration in Setup, create or select a delegated group. Then in Assignable Permission Set Groups, select the permission set groups that delegated admins can assign to users or remove. Delegated administrators can manage assignments for the permission set groups in their delegated group, but they can’t modify those permission set groups.
5. Align Fields Horizontally in Field Sections: – Control field alignment across columns by using a new property on Dynamic Forms Field Section components. The Align fields horizontally property prevents fields in multicolumn Field Sections from collapsing upward when there’s a gap due to differences in field heights. Fields remain horizontally aligned with their neighbors in the same row. But even with this property selected, if a field is hidden because of visibility rules, the fields in its column still collapse upward to fill the empty space.
   
   1. To see the new property, click a Field Section component on a Dynamic Forms-enabled page in Lightning App Builder.
   2. For example, these two versions of the same field section contain account fields. The left image shows the behavior without the new property selected. On the right, the horizontal alignment setting was selected, causing the Website field to stay aligned horizontally with Account Name instead of collapsing upward.
6. Optimize Your App Pages with the Accordion and Tabs Components: – Make your Lightning pages more organized and effective with the Accordion and Tabs components, now supported on app pages. The Accordion and Tabs components are container components that you can drop other components into to better organize your pages and improve page performance. Open an app page in the Lightning App Builder, and drag an Accordion or Tabs component onto the canvas. Put other components inside the accordion or tab sections. You can customize the labels of each tab and accordion section to whatever you want.
7. Declaratively Edit External Services Created by HTTP Callout: – With the general availability of Flow Builder HTTP Callout in Summer ’23, you can now declaratively edit external services that were originally created by HTTP Callout. Editing an external service is similar to the existing Modify behavior, except that you can change only the description and named credentials. To edit an operation, go to the external service’s Details page and select Edit HTTP Action.
8. The CASESAFEID Function Has Changed: – The CASESAFEID function now converts only valid Salesforce 15-character IDs to case insensitive 18-character IDs. If you pass in an invalid ID, the function returns the ID passed in. Previously, in Salesforce Classic, the function converted only valid Salesforce 15-character IDs. In Lightning Experience, the function converted any 15-character ID whether or not it was valid. The CASESAFEID function now behaves the same way in Lightning Experience and Salesforce Classic.
   1. For example, if you pass in an invalid ID of A01xx000003DHur, the function returns the ID A01xx000003DHur. This ID isn’t valid because it begins with a capital letter. If you pass in a valid ID of 001xx000003DHur, the function returns something like 001xx000003DHurAAG.
9. Quickly Create Full Sandboxes (Generally Available): – The Quick Create technology enhances the speed at which Full sandboxes are created or refreshed. Teams can focus more time on developing and testing solutions, and less time waiting for sandboxes to be built.
10. Enable Faster Account Sharing Recalculation by Not Storing Case and Contact Implicit Child Shares (Release Update): –To improve performance, Salesforce is changing the way that automatic account sharing recalculation works behind the scenes for the Case and Contact objects. We no longer store implicit child share records between accounts and their child case and contact records. Instead, the system determines whether users can access child case and contact records when they try to access them. This release update is available starting in Summer ’23.
11. View Knowledge Articles in LWR Sites with the Knowledge Article Component: – With the new Knowledge Article component, site visitors can view knowledge articles from their LWR sites. Previously, the Knowledge Article component was available only in Aura sites.
12. Manage Follow-Up Appointments from the Field: – Set up the Follow-Up Appointment Lightning web component (LWC) to let your mobile workers create and schedule follow-up appointments for customers directly from the mobile app, without contacting customer services.
    1. This feature is available in the Field Service mobile app for Android and iOS.
    2. Install the Follow-Up Appointment unmanaged package and configure the settings. Then, create a quick action using the LWC.
13. Trigger an External Action After a Prospect Engagement: – Now you can trigger an external action on any Account Engagement asset that has a completion action. For example, after a prospect completes a sign-up form, you can register the prospect for a webinar. You can send a text message after a prospect clicks a custom redirect link or send an alert to your sales team when a prospect visits a pricing page.
    
    1. This change applies to Account Engagement Growth, Plus, Advanced, and Premium editions.
14. Convert Unused Dynamic Lists to Static Lists: – Save processing power in your business unit by converting your old or unused dynamic lists to static lists. After you convert a dynamic list, you must manually add and remove prospects because the list no longer updates based on rule criteria. Select inactive or unused dynamic lists and use the table action dropdown menu to convert them to static. You can also convert individual lists from the record home.
    1. This change applies to all Account Engagement editions.
15. Copy Assets Between Account Engagement Business Units More Easily: – Share marketing assets, such as email templates, files, Engagement Studio programs, and custom redirects, across business units without manually recreating them. Work with your developer and use Account Engagement API V5 to query, read, and create assets as needed.
    1. This change applies to Account Engagement Growth, Plus, Advanced, and Premium editions.
16. Control Who Can Use Organization-Wide Email Addresses: – We heard you. You want greater control over who can use organization-wide email addresses in the From field on outgoing emails. Now you can use permission sets to limit who can use each organization-wide email address. As before, you can also use profiles or make each organization-wide email address available to all users.
    1. To add permission sets to an organization-wide email address, go to the Organization-Wide Addresses page in Setup.
17. Find Flow User Permissions More Easily: – Flow user permissions are now all consolidated under a new Flow and Flow Orchestration section in App Permissions. Previously, they were dispersed throughout System Permissions.
    1. For example, you want to add flow user permissions to a permission set. From Setup, in the Quick Find box, enter Permission Sets, and then select Permission Sets. Next, select the permission set you want to manage, and then click App Permissions. Last, select the permissions that you want to add.
18. Use Salesforce MFA for SSO Logins: – Now there’s a new and better way to use the Salesforce multi-factor authentication (MFA) service for SSO logins. After you enable MFA for your users, you can easily extend it to SSO by selecting a setting on your SSO configuration page. You control which SSO configurations use a third-party MFA service and which use Salesforce MFA. And unlike the previous method for applying Salesforce MFA to SSO logins, this method is fully compatible with Visualforce pages.
19. Track Consent Objects with Field Audit Trail: – Stay compliant with data privacy laws like the General Data Protection Regulation (GDPR), and maintain a record of your users’ consent changes in Field Audit Trail.
    
    1. This change is available to customers who purchased Privacy Center and either Field Audit Trail or Salesforce Shield add-on subscriptions.
    2. Track and retain changes made to these consent management objects.
       1. Authorization Form Consent
       2. Communication Subscription Consent
       3. Contact Point Consent
       4. Contact Point Type Consent
       5. Party Consent
20. Track File Usage in Near Real-Time with FileEvent (Generally Available): – Files are a treasure trove of sensitive and important information. Use FileEvent and FileEventStore, now generally available, to track file previews, uploads, and downloads from the UI and API. And because file events support transaction security policies, you can take steps to proactively control how users interact with specific files.
    
    1. This change is available to customers who purchased Salesforce Shield or Salesforce Event Monitoring add-on subscriptions.
21. Track Insecure Login Flows:- With Real-Time Event Monitoring, you can now monitor for insecure flows that can expose user credentials to security risks. Use LoginEvent and LoginEventStream to track OAuth user-agent and username-password flows.
    
    1. This change is available to customers who purchased Salesforce Shield or Salesforce Event Monitoring add-on subscriptions.
22. Schedule a Knowledge Article to Publish at a Specific Time:- Knowledge article authors and knowledge managers can publish articles in 15-minute intervals to better address the targeted nature of certain types of communications. For example, if you release a new update to your app, you can select a publishing time so that the knowledge article announcing the update gets published as close as possible to the time that the update goes live. Previously, you could schedule article publication only on a certain date.
    
    1. Select a publication time for a knowledge article.
23. Send Voice Messages in Enhanced Messaging Channels:- Voice is the new text, so make sure your agents don’t miss out. Agents can now easily record and send voice messages up to one minute long to customers in enhanced WhatsApp and enhanced Facebook Messenger channels. Previously, agents had to use a separate app to record messages and then send the audio files as attachments.
    
    1. This change applies to enhanced WhatsApp and enhanced Facebook Messenger channels. View required editions.
    2. To record a message during an enhanced messaging session, make sure your web browser has access to your microphone. Then, click the microphone icon in the message field (1) and start talking. Click the stop icon (2) when you’re done. Optionally, play back your message (3) or delete it (4). When you’re ready, send it to the customer (5).
    3. After a voice message is sent, the customer can access it for 30 days. Voice messages are included in the conversation transcript just like any other message.

1. Access Labels in Apex Dynamically: – Use the System.Label.get(namespace, label,language) method to get a custom label, optionally specifying a language. The feature now allows dynamic resolution of label names at run time, including overriding the user’s current language if a translation exists for the requested language. Previously, retrieving labels required compile-time knowledge of the label API name.
   1. From Setup, create custom label strings and then assign translated values by turning on Translation Workbench and adding translation mapping.
   2. Retrieve the label for a default language setting or for a language and namespace by using System.Label.get(namespace, label, language). You can also check if translation exists for a label and language in a namespace by using Label.translationExists(namespace, label,language). You can’t access labels that are protected in a different namespace.
2. Use the Iterable Interface with Set Type: – The Set class now implements the Iterable interface, so you can directly iterate over sets. Both sets and lists are iterable, allowing for more code reuse.
   1. This example uses the String.join method with a Set, which was previously unsupported because Set didn’t implement Iterable.
      Copy Code Copied Use a different Browser

      
      Set<String> letters = new Set<String>{'a','b','c','d'};
      System.debug(String.join(letters, '...'));
      
      

3. Query Five Levels of Parent-to-Child Relationships in SOQL Queries: – SOQL now supports relationship queries that traverse up to five levels of parent-child records. Use a single SOQL query to get parent-child records from five different levels. This ability is limited to SOQL queries via the REST and SOAP query calls on standards and custom objects.
   1. In API version 58.0 and later, SOQL relationship queries can contain a parent root as the first level of the query and child relationships up to four levels deep from the parent root.
   2. This example SOQL relationship query returns records from the parent object Account and its child objects Contacts, Assets, WorkOrders, and WorkOrderLineItems.
      Copy Code Copied Use a different Browser

      
      SELECT Name,
          (SELECT LastName,
              (SELECT AssetLevel,
                  (SELECT Description,
                      (SELECT LineItemNumber FROM WorkOrderLineItems)    
                  FROM WorkOrders)    
              FROM Assets)    
          FROM Contacts)    
      FROM Account
      

4. Attribute Names Support More Patterns: – Attribute name restrictions are loosened to support more use cases. Previously, issues could arise when attribute names were used with a less restrictive syntax environment, such as with a Java-based compiler. Additionally, only a subset of all the possible public properties could be addressed declaratively via the template. Some patterns like $myattribute and _myattribute are valid public properties that couldn’t set set via an LWC template.
   1. This change applies to custom Lightning web components in Lightning Experience, Experience Builder sites, and all versions of the Salesforce mobile app. This change also applies to Lightning web components in Open Source.
   2. Attribute names can now start with:
      1. An underscore (_)
      2. A dollar sign ($)
      3. Additionally, attribute names can include duplicate underscores (__) and an underscore followed by a hyphen(_-). Also, a hyphen followed by an underscore (-_) is allowed if the hyphen isn’t the first character in the attribute name. For example, these attribute names are valid.
         1. _myattribute
         2. $myattribute
         3. my_-attribute
5. Assign CSS Stylesheets to a Component: – Now you can extend stylesheets from a superclass component to a subclass component using super.stylesheets. The new stylesheets static property on the LightningElement constructor loads styles from CSS stylesheets into light DOM and shadow DOM components. Previously, CSS custom properties and CSS ::part() were the only standard mechanisms for customizing components. Also, you couldn’t directly reference stylesheets from an extended base class.
   1. This change applies to custom Lightning web components in Lightning Experience, Experience Builder sites, and all versions of the Salesforce mobile app. This change also applies to Lightning web components in Open Source.
   2. The stylesheets property accepts a static array of stylesheets, and its default value is an empty array. Stylesheets are injected into a component in the order that they’re listed in the stylesheets array.
6. Create Scoped Slots in Light DOM: – Scoped slots are now supported in light DOM Lightning web components. Use scoped slots to access data from a child component and then render it in slotted content inside of a parent component. Because the slotted content belongs to the parent component, any styles on the parent also apply to the content of the scoped slot.
   1. This change applies to custom Lightning web components in Lightning Experience, Experience Builder sites, and all versions of the Salesforce mobile app. This change also applies to Lightning web components in Open Source.
   2. The child component must use light DOM. Scoped slots in shadow DOM aren’t supported. The parent component can be a light DOM or shadow DOM component.
   3. To introduce scoped slots into your components, add the directives lwc:slot-data and lwc:slot-bind to the parent and child components, respectively. See Lightning Web Components Developer Guide: HTML Template Directives for guidance about how to use these directives.
      Copy Code Copied Use a different Browser

      
      <!-- c/parent.html -->
      <template> <!-- Parent component doesn’t need to be light DOM -->
          <c-child>
              <template lwc:slot-data="item">
                  <span>{item.id} - {item.name}</span>
              </template>
          </c-child>
      </template>
      
      
      <!-- c/child.html -->
      <template lwc:render-mode="light"> <!-- Child must be light DOM -->
          <ul>
              <template for:each={item} for:item="item">
                  <li key={item.id}>
                      <slot lwc:slot-bind={item}</slot>
                  </li>
              </template>
          </ul>
      </template>
      

7. Set Dynamic Values for the Slot Attribute in Lightning Web Components: – Now you can dynamically specify a value for the slot attribute of an HTML element. Previously, this value could only be a static string.
   
   1. This change applies to custom Lightning web components in Lightning Experience, Experience Builder sites, and all versions of the Salesforce mobile app. This change also applies to Lightning web components in Open Source.
   2. In this example, the <span> element has a slot attribute set to the variable dynamicName.
      Copy Code Copied Use a different Browser

      
      <template>
          <c-item>
              <span slot={dynamicName}></span>
          </c-item>
      </template>
      

   3. This change applies only to the slot attribute of HTML elements. It doesn’t impact attributes of <slot> elements. For example, you still must pass a static string into the attribute name for a <slot> element.
      Copy Code Copied Use a different Browser

      
      <template>
         <slot name=”staticName”></slot>
      </template>
      

8. Salesforce Flow Enhancements: – There are several enhancements in Salesforce Flow as follows:
   1. Send Salesforce Data to an External Server Without Code via HTTP Callout (Beta): – If you can’t GET enough with HTTP Callout, now you can use the POST method to send Salesforce data to an external server in Flow Builder. Previously, only the GET method was available, which you can use to bring external data into Salesforce.
      
      1. Select POST (Beta) to make a callout request that adds the resource to the external server.
      2. Enter a sample JSON request body that the API expects when configuring the HTTP Callout, and the API infers the external data structure.
      3. After you create the callout action, set the body for the flow by creating a resource and selecting the Apex class for the external server’s body.
      4. After you configure the action, add an Assignment element before the HTTP Callout action element, and assign values for each of the fields on the resource.
      5. When the flow runs, the values are set on the resource and the data is created in the external server.
   2. Build Screens with Reactive Components (Beta): – Configure supported standard screen components or your custom Lightning web components to react to changes in other Flow Screen components on the same screen. Build screens that feel like single-page apps and reduce the number of screens your user needs to click through. Previously, components on the same screen couldn’t talk to each other. If you needed one component to influence another, you placed them on separate screens.
      1. Screen Flow reactivity means your Screen Flow component updates the properties of other components on the screen based on user input. For example, you can make a Name component’s First Name field react to the Text component output.
      2. Your existing flows start displaying reactivity when you opt into Beta and explicitly save them with API version 57.0 and later.
      3. From Setup, on the Process Automation Settings page, select Opt into Reactive Screens Beta. Then add components to your screen, upgrade your flow to Runtime API Version 57.0, and save and run the flow as usual. The input component reacts to changes from the output component.
   3. Update the Screen in Real-Time using Formulas (Beta): – Working with supported formula functions, you can configure a screen component to perform real-time formula calculations and logic. When the flow detects a change in any of the values in the formula, it recalculates and updates the value of the screen component.
      1. For example, the user sees a real-time screen update of a price discount, tax amounts, and shipping costs. Now it isn’t necessary for users to remember what they selected on a previous screen, thus less confusion and fewer clicks.
      2. Your existing flows only start displaying reactivity when you opt into the Beta program and explicitly save them with API version 57.0 and later.
      3. From Setup, on the Process Automation Settings page, select Opt into Reactive Screens Beta. Then add components to your screen, upgrade your flow to Runtime API Version 57.0, and save and run the flow as usual. The input component reacts to changes from the output component.
   4. Log Emails Sent with the Send Email Action: – Now you can automatically log emails to a record’s Activity Timeline when using the Send Email action. You can log an email to a recipient record, which includes leads, contacts, and person accounts. You can also log an email to a non-recipient record, like an account or opportunity. Or, you can log an email to both. Previously, emails sent using the Send Email action couldn’t be automatically tracked in Activity Timelines.
      1. For example, to send and log an email to a contact record and also log to its related account record, set Log Email on Send to {!$GlobalConstant.True} (1). Then, set Recipient ID to the contact record’s ID (2) and Related Record ID to the account record’s ID (3).
   5. Use Email Templates in the Send Email Action: – Reuse email content with Lightning and Classic email templates in the Send Email action. If your email template has merge fields, you can use the recipient record or a related record to populate the merge fields. Or, you can use both. Previously, you couldn’t use email templates in the Send Email action.
      1. or example, to send an email to a contact using an email template with Contact and Account object merge fields, set Email Template ID to the ID of the email template to use (1). Then, set Recipient ID to the contact record’s ID (2) and Related Record ID to the related account record’s ID (3).
   6. Search and Display Data Table Results in Screen Flows: – Now users can search and filter their Data Table record results. The search returns the first 1,500 items. Initially, 200 records display. As you scroll through the results, additional records load progressively in groups of 100. The search results also show the number of items displayed and the total number of items found.
      1. Add the Data Table component to a screen flow, and select Show search bar.
   7. Reference Choice Sets Only in Choice Components: – When configuring flow screen components, Flow Builder only lets you reference record choice sets, collection choice sets, or picklist choice sets from a single location – a choice component’s data source. Previously you could set the reference from several other places such as conditions, filters, or component default values, but those references were unsupported and could generate an error. Now you won’t see these options as a choice in places where they are no longer allowed.
      1. If you have unsupported references in existing flows, don’t worry: your flows continue to run as they did in ’Spring 23. This change ensures that no new flows contain unsupported references.
   8. View More Elements on the Flow Builder Canvas: – Now you can see more elements on the Flow Builder canvas with a new compact layout and a smaller Add Element button. Previously, elements were further spread out, requiring you to move the canvas more frequently to see additional elements.
9. Flow Orchestrator: – There are several enhancements in Flow Orchestrator as follows:
   1. Get Refreshed Record Variables When an Orchestration Resumes: – When you reference a record variable or a record collection in an orchestration configured to run on API version 58.0 and later, records are refreshed with their latest values each time the orchestration run resumes. In an autolaunched orchestration run, all referenced records are refreshed. In a record-triggered orchestration, all referenced records except $Record_Prior are refreshed. To refresh record variables in an existing orchestration, save a new copy and set the API version to 58.0 or later. Record values aren’t visible in the debugger details for an orchestration run.
      
   2. Control the Running Context of an Orchestration: – Choose the context to launch and resume an autolaunched orchestration to control the access associated orchestration runs have to Salesforce data. The selected context also controls the record-level access for evaluation flows and background steps when the associated orchestration runs in a system context. A record-triggered orchestration always runs and resumes in system context. For orchestrations running on API version 58.0 and later, the context used to resume an orchestration is always the context of how the orchestration was launched.
      1. In the autolaunched orchestration’s Edit version properties window, under Advanced, select an option from the How to Run the Orchestration dropdown.
   3. Create Steps to Run MuleSoft Actions: – You can now call a MuleSoft action from a step in your orchestration. The step runs asynchronously in system context.
      
      1. From an orchestration stage’s Add Step menu, select MuleSoft Step.
      2. Enter information about the step, and select the MuleSoft action that you want to run.
10. Manage Toast Notifications with a Toast Container (Beta) – Fire and manage a list of toast notification message components, including their position, with lightning/toastContainer for LWR sites. The module creates a container that handles and displays your page-level toast notifications.
    1. This change applies to Lightning Web Runtime (LWR) sites accessed through Lightning Experience in all editions.
    2. Use the maxToasts attribute to set the maximum number of toasts in the container. Use containerPosition to position the container, and use toastPosition to position the toast components within it.
       Copy Code Copied Use a different Browser

       
       // c/myApp.js
       import { LightningElement } from 'lwc';
       import ToastContainer from 'lightning/toastContainer';
       
       export default class MyApp extends LightningElement {
           connectedCallback() {
               const toastContainer = ToastContainer.instance();
               toastContainer.maxShown = 5;
               toastContainer.toastPosition = 'top-right';
           }
       }
       

11. Develop Offline-Ready LWCs with the LWC Offline Test Harness: – The LWC Offline Test Harness (or Test Harness, for short) is a lightweight testing and debugging app that enables developers to iteratively develop, test, and debug Lightning web components for use in LWC Offline-based mobile apps. The streamlined app experience accelerates the interactive development lifecycle, making it easy to quickly test incremental improvements and fixes to your mobile LWCs.
    1. This tool is publicly available for download as both an app file (iOS) and an APK file (Android).
    2. For details on how to use Test Harness during offline component development, see Develop Offline-Ready LWCs with the LWC Offline Test Harness in the Mobile Offline Developer Guide.
12. Validate Your Lightning Web Components for Offline Use with the Komaci Static Analyzer: – The Komaci Static Analyzer (or static analyzer, for short) is a new developer tool that validates code to ensure it can be used in offline environments. Perfect for developers who are looking to try their hand at writing offline functionality. (Or are already doing it!)
    1. This feature is publicly available as an ESLint plugin, and can be installed with a package manager such as npm or Yarn.
    2. For details on how to use Komaci Static Analyzer during offline component development, see Validate Lightning Web Components for Offline Use in the Mobile Offline Developer Guide.
13. Configure Stack Depth of Chained Queueable Jobs (Beta): – You can now set a maximum stack depth of Queueable jobs, overriding the default limit of five in Developer and Trial Edition organizations.
    1. Enqueue jobs by using the new System.enqueueJob() overload. The method overload has an optional AsyncObjects parameter where you can specify the maximum stack depth and the minimum queue delay.
    2. Use these methods in the new System.AsyncInfo class to determine the current and maximum stack depths and to get the minimum queueable delay.
       1. getCurrentQueueableStackDepth()
       2. getMaximumQueueableStackDepth()
       3. getMinimumQueueableDelayInMinutes()
       4. hasMaxStackDepth()
    3. This example uses stack depth to terminate a chained job and prevent it from reaching the daily maximum number of asynchronous Apex method executions.
       Copy Code Copied Use a different Browser

       
       // Fibonacci
       public class FibonacciDepthQueueable implements Queueable {
          
           private integer nMinus1, nMinus2;
              
           public static void calculateFibonacciTo(integer depth) {
               AsyncOptions asyncOptions = new AsyncOptions();
               asyncOptions.MaximumQueueableStackDepth = depth;
               System.enqueueJob(new FibonacciDepthQueueable(null, null), asyncOptions);
           }
              
           private FibonacciDepthQueueable(integer nMinus1param, integer nMinus2param) {
               nMinus1 = nMinus1param;
               nMinus2 = nMinus2param;
           }
          
           public void execute(QueueableContext context) {
              
               integer depth = AsyncInfo.getCurrentQueueableStackDepth();
              
               // Calculate step
               integer fibonacciSequenceStep;
               switch on (depth) {
                   when 1, 2 {
                       fibonacciSequenceStep = 1;
                   }
                   when else {
                       fibonacciSequenceStep = nMinus1 + nMinus2;
                   }
               }
              
               System.debug('depth: ' + depth + ' fibonacciSequenceStep: ' + fibonacciSequenceStep);
              
               if(System.AsyncInfo.hasMaxStackDepth() &&
                  AsyncInfo.getCurrentQueueableStackDepth() >= 
                  AsyncInfo.getMaximumQueueableStackDepth()) {
                   // Reached maximum stack depth
                   Fibonacci__c result = new Fibonacci__c(
                       Depth__c = depth,
                       Result = fibonacciSequenceStep
                       );
                   insert result;
               } else {
                   System.enqueueJob(new FibonacciDepthQueueable(fibonacciSequenceStep, nMinus1));
               }
           }
       }
       

14. Manage DML Exceptions in User-Mode Database Operations: –Database methods for user-mode DML operations generate the correct DMLException. Previously they generated a SecurityException. This behavior is versioned, and the correct exception is generated in API version 58.0 and later versions.
    1. In this example, a DmlException is generated because the required Name field isn’t populated.
       Copy Code Copied Use a different Browser

       
       Account acct = new Account();
       try {
          insert as user acct;
          Assert.fail('DmlException expected due to missing Name field');
       } catch (Exception ex) {
          Assert.isTrue(ex.getMessage().contains('REQUIRED_FIELD_MISSING'));
                // This assertion fails with API versions below v58.0 because a SecurityException is generated
                Assert.isInstanceOfType(ex, DmlException.class);
       

15. Deploy Scalable Apps and Analyze System Performance with Scale Center: – Scale Center provides self-service and near-real-time access to performance metrics. Diagnose root causes and act on scale issues earlier in your development cycle. Improve the scalability of your Salesforce implementation. Identify issues with performance or scale. Launch analyses to troubleshoot errors. Retrieve customized insights and recommendations.
    1. This service is available with a restricted license. Users opt to use Scale Center and are subject to the applicable terms provided at Agreements and Terms.
    2. Enable Scale Center in sandboxes and in production on first party infrastructure (1P) and Hyperforce. From Setup, in the Quick Find box, enter Scale Center, and then select Scale Center. To get access, contact your program architect or account executive.
    3. Start an analysis report.
16. Track the Publishing of Platform Events with Apex Publish Callbacks (Generally Available): –  Get the final result of an EventBus.publish call through an Apex publish callback that you implement. After you receive the final publish result, you can decide what action to take, such as attempting to republish failed events. Because event publishing is asynchronous, the publish operation is queued in Salesforce. When no immediate errors are returned and when resources become available, the system carries out the queued publish call. Without the callback, you can get only the intermediate queueing result in Database.SaveResult of an EventBus.publish call, not the final result.
    1. To track failed event publishes, write an Apex class and implement the EventBus.EventPublishFailureCallback interface. If the asynchronous publish operation fails, the onFailure method is invoked. In the implemented onFailure method, you can write logic to act in response to the final result of the publishing operation. The result parameter contains the EventUuid field values for each failed event, but doesn’t contain the data for the event. Use the getEventUuids method to correlate the failure results with the published events.
       Copy Code Copied Use a different Browser

       
       public class FailureCallback implements EventBus.EventPublishFailureCallback {
             
          public void onFailure(EventBus.FailureResult result) {
              // Your implementation.
              // Get event UUIDs from the result
              List<String> eventUuids = result.getEventUuids();
              // ...
          }        
       }
       

    2. To track successful event publishes, write an Apex class and implement the EventBus.EventPublishSuccessCallback interface. If the asynchronous publish operation succeeds, the onSuccess method is invoked. In the implemented onSuccess method, you can write logic to act in response to the final result of the publishing operation.
       Copy Code Copied Use a different Browser

       
       public class SuccessCallback implements EventBus.EventPublishSuccessCallback {
             
          public void onSuccess(EventBus.SuccessResult result) {
              // Your implementation.
              // Get event UUIDs from the result
              List<String> eventUuids = result.getEventUuids();
              // ...
          }        
       }
       

    3. Because most publish calls typically succeed, processing successful event publishes isn’t likely a concern. A large volume of events can be published successfully, so watch the performance and Apex limits when processing results.