Top Salesforce Concepts: A Detailed Discussion

1. Organization (Org)

Your Salesforce instance. It’s a single, secure, and isolated environment containing all your data, applications, and customizations.

Each customer gets one or more orgs (e.g., production, sandbox).
Governed by limits on data storage, user licenses, and API calls.

2. Objects

Databases tables in Salesforce. They store data for your organization.

Standard Objects: Provided out-of-the-box (e.g., Account, Contact, Opportunity, Lead, Case).
Custom Objects: Created by administrators or developers to store organization-specific data (names end with __c).

3. Fields

Columns within an object that store specific pieces of information about a record.

Various data types (e.g., Text, Number, Date, Picklist, Lookup, Master-Detail).
Can be standard or custom (names end with __c).

4. Records

Individual rows in an object’s database table, representing a specific instance of the object (e.g., a specific Account named “Acme Corp”).

5. Relationships

Connections between different objects, allowing you to link related data.

Lookup Relationship: Loosely links two objects. The parent record is not required for the child record to exist.
Master-Detail Relationship: Tightly links two objects. The child record is detail record dependent on the master record. Deleting the master record also deletes the detail records.
Many-to-Many Relationship: Achieved using a junction object (a custom object with two Master-Detail relationships to the objects being linked).

6. Salesforce User Interface (UI)

How users interact with Salesforce.

Classic: The original Salesforce UI, still used by some organizations.
Lightning Experience: The modern and faster UI, offering enhanced features and customization options.

7. Declarative Development

Building and customizing Salesforce using clicks, not code.

Tools include: Setup Menu, Object Manager, Flow Builder, Process Builder, Workflow Rules, Validation Rules, Formula Fields, Report Builder, Dashboard Builder.
Ideal for administrators and business users to make configurations without coding knowledge.

8. Programmatic Development

Building and customizing Salesforce using code.

Apex: Salesforce’s proprietary object-oriented programming language, used for backend logic, triggers, and custom controllers.
Lightning Web Components (LWC): A modern JavaScript framework for building reusable UI components.
Aura Components: An older component-based framework for building dynamic UI (being superseded by LWC).
Visualforce: A tag-based markup language for creating custom UI pages (being superseded by LWC).

9. Apex Triggers

Code that executes before or after specific data manipulation language (DML) events occur on Salesforce records (e.g., before insert, after update).

Used to automate business logic based on record changes.
Must be bulkified to handle multiple records efficiently and avoid governor limits.

// Example Apex Trigger
trigger AccountTrigger on Account (before insert, before update) {
    for (Account acc : Trigger.new) {
        if (String.isBlank(acc.Description)) {
            acc.Description = 'Initial Description';
        }
    }
}

10. Governor Limits

Runtime limits enforced by the Salesforce platform to ensure fair resource sharing in the multi-tenant environment.

Limits on SOQL queries, DML statements, CPU time, heap size, etc.
Developers must write efficient code to avoid exceeding these limits.

11. Salesforce Object Query Language (SOQL)

A language used to query data from the Salesforce database.

Similar to SQL but specific to Salesforce objects and fields.
Used in Apex, Visualforce, Lightning components, and APIs.

// Example SOQL Query
List<Account> accounts = [SELECT Id, Name, Industry FROM Account WHERE BillingCountry = 'USA' LIMIT 10];

12. Data Manipulation Language (DML)

Statements used in Apex to perform operations on Salesforce records.

Common operations: insert, update, delete, upsert, undelete.
Must be bulkified to handle multiple records efficiently.

// Example DML Operation
Account newAccount = new Account(Name='Test Account');
insert newAccount;

13. Security Model

Controls who can see and do what in Salesforce.

Involves: Organization-Wide Defaults (OWD), Role Hierarchy, Sharing Rules, Profiles, Permission Sets, Field-Level Security.
Ensures data privacy and appropriate access levels.

14. Profiles

Define the base-level permissions and access to objects, fields, and applications for a set of users.

Assigned to each user.
Control what a user *can* do.

15. Permission Sets

Grant additional permissions to users beyond what their profile allows.

Can be assigned to multiple users.
Provide granular access to specific features and functionalities.

16. Workflow Rules

Automate actions based on specific criteria when a record is created or edited.

Can trigger actions like sending email alerts, updating fields, creating tasks, and sending outbound messages.
Being largely superseded by Process Builder and Flows for more complex automation.

17. Process Builder

A declarative tool for automating business processes using a visual point-and-click interface.

More powerful and versatile than Workflow Rules, allowing for more complex logic and multiple actions.
Can trigger Apex code, invoke flows, create records, update records, send emails, post to Chatter, and more.

18. Flows

A powerful declarative tool for building complex automated business processes with a visual, flow-chart-like interface.

Supports screen flows (user interaction), auto-launched flows (triggered by events), record-triggered flows, schedule-triggered flows, and more.
Offers advanced features like loops, decisions, data manipulation, and integration with Apex and external systems.

19. Reports and Dashboards

Tools for analyzing and visualizing Salesforce data.

Reports: Provide lists or summaries of data based on defined criteria.
Dashboards: Visual representations of key metrics and trends using charts and tables from multiple reports.

20. Salesforce APIs

Allow external applications and systems to interact with Salesforce programmatically.

REST API: A modern, lightweight API using JSON for data exchange.
SOAP API: A more traditional, XML-based API.
Bulk API: Optimized for loading and extracting large volumes of data.
Metadata API: Used for managing Salesforce metadata (e.g., deploying changes).

21. Sandbox Environments

Isolated copies of your production Salesforce org used for development, testing, and training without affecting live data or users.

Different types of sandboxes (Developer, Developer Pro, Partial Copy, Full Sandbox) with varying data and configuration copy limits.
Essential for implementing changes and new features safely.

22. Deployment

The process of moving metadata (configurations, code) from one Salesforce environment (e.g., sandbox) to another (e.g., production).

Tools include Change Sets (declarative), Salesforce CLI (command-line interface), and various third-party deployment tools.
Requires careful planning and testing to ensure a smooth transition.

23. AppExchange

Salesforce’s marketplace for third-party applications, components, and consulting services that extend the platform’s functionality.

Offers solutions for various business needs, from marketing automation to accounting.
Provides both free and paid listings.

24. Lightning Web Components (LWC)

A modern, standards-based framework for building reusable user interface components on the Salesforce platform.

Leverages web standards like HTML, JavaScript, and CSS.
Offers better performance and aligns with modern web development practices compared to Aura Components.

// Example LWC JavaScript
import { LightningElement, api } from 'lwc';

export default class HelloWorld extends LightningElement {
    @api greeting = 'World';
}

25. Aura Components

An older component-based framework for building dynamic user interfaces for both desktop and mobile Salesforce experiences.

Uses a proprietary markup language and JavaScript.
While still supported, LWC is the preferred framework for new development.

26. Salesforce Mobile App

A native mobile application that allows users to access their Salesforce data and perform tasks on the go.

Customizable with Lightning components and mobile-specific features.
Provides access to standard Salesforce objects and custom applications.

27. Batch Apex

A framework for processing large volumes of records asynchronously in batches to avoid governor limits.

Allows you to define a job that processes records in smaller, manageable chunks.
Essential for data migrations, large data updates, and scheduled jobs.

// Example Batch Apex Class
global class AccountProcessor implements Database.Batchable<sObject> {
    global Database.QueryLocator start(Database.BatchableContext bc) {
        return Database.getQueryLocator([SELECT Id, Name FROM Account WHERE Industry = 'Technology']);
    }

    global void execute(Database.BatchableContext bc, List<Account> scope) {
        for (Account acc : scope) {
            acc.Description = 'Processed by Batch Apex';
        }
        update scope;
    }

    global void finish(Database.BatchableContext bc) {
        // Optional finish logic
    }
}

28. Queueable Apex

A framework for executing asynchronous processes that can be chained together and can use sObject variables.

More flexible than Future methods for asynchronous processing.
Allows for chaining of jobs for sequential asynchronous operations.

// Example Queueable Apex Class
public class AccountQueueable implements Queueable {
    private List<Id> accountIds;

    public AccountQueueable(List<Id> accountIds) {
        this.accountIds = accountIds;
    }

    public void execute(QueueableContext context) {
        List<Account> accountsToUpdate = [SELECT Id, Description FROM Account WHERE Id IN :accountIds];
        for (Account acc : accountsToUpdate) {
            acc.Description = 'Updated by Queueable';
        }
        update accountsToUpdate;

        // Optional chaining to another Queueable job
        // System.enqueueJob(new AnotherQueueableJob());
    }
}

29. Future Methods

Methods annotated with @future that run asynchronously when system resources become available.

Primarily used for long-running operations that should not block the user interface or exceed synchronous governor limits.
Cannot directly access sObject variables; IDs must be passed instead.

// Example Future Method
public class AsyncOperations {
    @future(callout=true)
    public static void makeHttpRequest(String url) {
        Http http = new Http();
        HttpRequest req = new HttpRequest();
        req.setEndpoint(url);
        req.setMethod('GET');
        HttpResponse res = http.send(req);
        System.debug(res.getBody());
    }
}

30. Salesforce Connect

Enables your Salesforce org to access live data from external systems without writing code and without copying the data into your org.

Uses external objects to map to tables in external data sources.
Supports various data sources through adapters.

31. Salesforce Lightning Design System (SLDS)

Salesforce’s official CSS framework and component library for building user interfaces consistent with the Lightning Experience.

Provides pre-styled components and guidelines for creating accessible and visually appealing applications.
Ensures a consistent user experience across the Salesforce platform.

32. Static Resources

Used to upload and reference static content like CSS files, JavaScript files, images, and zip files within your Salesforce org.

Essential for styling and adding client-side functionality to Lightning components and Visualforce pages.
Accessed using the $Resource global variable.

<!-- Example referencing a static resource in LWC -->
<template>
    <lightning-card title="Static Resource Example">
        <img src={logoUrl} alt="Company Logo"/>
    </lightning-card>
</template>

<script>
    import { LightningElement } from 'lwc';
    import logo from '@salesforce/resourceUrl/company_logo'; // Assuming 'company_logo' is the name of your static resource

    export default class StaticResourceExample extends LightningElement {
        logoUrl = logo;
    }
</script>

33. Custom Metadata Types

Customizable, deployable, packageable, and upgradeable application metadata.

Similar to custom objects but the records are metadata rather than data.
Useful for storing application configuration data that can be easily migrated between orgs.

34. Custom Settings

Similar to custom objects, but designed for storing application-level configuration data that can be easily accessed by Apex code and formulas without SOQL queries (for List Custom Settings).

Two types: List Custom Settings (org-wide data sets) and Hierarchy Custom Settings (data that varies based on user hierarchy).
Offer efficient access to configuration values.

35. Validation Rules

Define criteria that data must meet before a record can be saved. If the criteria are not met, an error message is displayed to the user.

Declarative way to enforce data quality and consistency.
Can use formulas to define complex validation logic.

36. Formula Fields

Read-only fields whose value is calculated based on a formula you define. The formula can reference other fields on the same object or related objects.

Declarative way to display calculated information without writing code.
Dynamically updated whenever the underlying data changes.

37. Roll-Up Summary Fields

Display aggregated values from detail records on a master record in a master-detail relationship.

Supported aggregations include COUNT, SUM, MIN, and MAX.
Declarative way to summarize related data.

38. Salesforce Connect (OData 2.0 and 4.0 Adapters)

Specific adapters for Salesforce Connect that allow real-time access to data exposed via the Open Data Protocol (OData).

Enables integration with a wide range of external systems that support OData.
Data is accessed on demand without being stored in Salesforce.

39. External Objects

Custom objects in Salesforce that map to tables in external data sources defined by Salesforce Connect.

Allow users and the platform to interact with external data almost as if it were native Salesforce data.
Support SOQL queries with some limitations.

40. Salesforce Identity

Provides services for managing user identities, authentication, and single sign-on (SSO) across multiple applications and services, including Salesforce.

Enables secure and seamless access for users.
Supports various identity standards like SAML and OAuth.

41. Salesforce Shield

A suite of security features that provide enhanced control over data privacy, compliance, and governance.

Includes features like Platform Encryption, Event Monitoring, and Field Audit Trail.
Helps organizations meet stringent security and regulatory requirements.

42. Platform Events

A scalable and secure platform messaging service that allows you to build event-driven applications within and across Salesforce and external systems.

Publish/subscribe model for real-time communication.
Events are defined as custom objects.

// Example Publishing a Platform Event
EventBus.publish(new Cloud_News__e(Headline__c = 'New Product Released!'));

43. Change Data Capture (CDC)

A service that publishes change events when Salesforce records are created, updated, deleted, or undeleted.

Enables near real-time data synchronization with external systems.
Subscribers can listen to specific object change events.

44. Apex REST Callouts

The ability for Apex code to make HTTP callouts to external RESTful web services.

Uses the Http and HttpRequest classes.
Essential for integrating Salesforce with external APIs.

// Example Apex REST Callout
Http http = new Http();
HttpRequest req = new HttpRequest();
req.setEndpoint('https://api.example.com/data');
req.setMethod('GET');
HttpResponse res = http.send(req);
if (res.getStatusCode() == 200) {
    System.debug(res.getBody());
}

45. Apex SOAP Callouts

The ability for Apex code to make callouts to external SOAP-based web services.

Involves generating Apex code from WSDL files.
Used for integrating with legacy systems that expose SOAP APIs.

46. Salesforce Functions

Serverless compute service that allows you to write and run code (Node.js or Java) that extends Salesforce’s capabilities.

Can be invoked from Apex triggers and flows.
Useful for offloading complex logic or integrating with external services.

47. Lightning Message Service (LMS)

A messaging system that allows communication between different Lightning Web Components (across the DOM) and between LWC and Aura components on the same page.

Enables building more modular and interactive user interfaces.
Uses a publish/subscribe model.

48. Salesforce CLI (Command Line Interface)

A powerful command-line tool that allows developers and administrators to interact with their Salesforce orgs for development, automation, and management tasks.

Supports tasks like creating and managing orgs, deploying and retrieving metadata, executing tests, and running SOQL queries.
Essential for modern Salesforce development practices.

49. Salesforce DX (Developer Experience)

A set of tools and practices aimed at improving the developer workflow for building and deploying Salesforce applications.

Includes the Salesforce CLI, scratch orgs (temporary, disposable orgs for development), and source control integration.
Promotes team-based development and continuous integration/continuous delivery (CI/CD).

50. Scratch Orgs

Temporary, easily configurable, and disposable Salesforce environments that developers can quickly spin up for development and testing purposes.

Source-driven, meaning their configuration is defined in a project file.
A key component of the Salesforce DX workflow.

51. Managed Packages

Distributable units of Salesforce components (like objects, Apex code, Lightning components) that are typically created by ISVs (Independent Software Vendors) and installed into other Salesforce orgs.

Intellectual property is protected, and ISVs can release upgrades seamlessly.
Namespace prefixes prevent naming conflicts with existing components in the installing org.

52. Unmanaged Packages

Distributable units of Salesforce components where the code and configuration are fully editable by the installing organization.

Typically used for sharing open-source projects or for one-time deployments between related orgs where customization is expected.
No upgrade path provided by the original developer.

53. Namespaces

Unique identifiers, consisting of a prefix, that are used to distinguish components (objects, Apex classes, etc.) created by a specific developer or ISV, especially within managed packages.

Prevent naming collisions between different packages or custom development within an org.
Essential for the AppExchange ecosystem.

54. Apex Testing Framework

Salesforce’s built-in framework for writing and running unit tests for Apex code.

Ensures code quality, reliability, and proper functionality.
Code coverage requirements must be met for deploying Apex code to production.
Uses annotations like @isTest and methods in the System.assert class.

// Example Apex Test Class
@isTest
private class AccountProcessorTest {
    @isTest
    static void testAccountCreation() {
        Test.startTest();
        Account acc = new Account(Name='Test Account');
        insert acc;
        Account insertedAcc = [SELECT Id, Name FROM Account WHERE Id = :acc.Id];
        System.assertEquals('Test Account', insertedAcc.Name);
        Test.stopTest();
    }
}

55. Mock Testing

A testing technique where dependencies of the code being tested are replaced with controlled test doubles (mocks) to isolate the unit under test and ensure predictable behavior.

Essential for testing code that makes callouts or interacts with other complex services.
Salesforce provides classes like HttpCalloutMock for mocking HTTP callouts.

56. Lightning Out

A feature that allows you to run Lightning components (both Aura and LWC) within external web applications, outside of the Salesforce platform.

Enables embedding Salesforce UI elements into other websites or custom web applications.
Requires authentication and configuration.

57. Canvas Apps

Allow you to integrate third-party web applications seamlessly within Salesforce, either as part of a page layout or as a standalone app.

Use an <iframe> to embed the external application.
Salesforce provides signed request parameters for secure communication between Salesforce and the canvas app.

58. Salesforce Connect (Cross-Org Adapter)

A specific adapter for Salesforce Connect that allows you to access data from another Salesforce org in real time, without replicating the data.

Useful for organizations with multiple Salesforce instances that need to share data.
Requires configuring a connected app and defining external objects.

59. Heroku Connect

A service that provides seamless data synchronization between Salesforce and Heroku Postgres databases.

Allows you to build custom applications on Heroku that interact with your Salesforce data.
Supports bidirectional data flow.

60. Trailhead

Salesforce’s free, gamified online learning platform that teaches you about various Salesforce features, development, and administration topics through interactive modules and projects.

An invaluable resource for learning Salesforce skills at your own pace.
Offers badges and points for completing modules.

61. Salesforce Flow Trigger Explorer

A tool within Salesforce Setup that provides a consolidated view of all record-triggered flows, workflow rules, and process builder processes configured for a specific object.

Helps administrators understand the automation configured for an object and manage the order of execution.

62. Debug Logs

System-generated logs that provide detailed information about the execution of Apex code, workflow rules, validation rules, and other Salesforce processes.

Essential for troubleshooting and identifying performance issues.
Can be configured with different levels of detail and filtered for specific users or processes.

63. Einstein Automate (formerly Flow Orchestrator)

A feature that allows you to build complex, multi-user, multi-step automated processes that span across different parts of Salesforce and potentially external systems.

Provides a visual interface for designing and managing orchestrations.
Enables more sophisticated automation scenarios than standard Flows.

64. Dynamic Apex

The ability to write Apex code that can construct and execute SOQL and DML statements at runtime, allowing for more flexible and adaptable logic.

Useful for building generic solutions or when the specific objects or fields to be queried or manipulated are not known at compile time.
Requires careful consideration of security risks (e.g., SOQL injection).

// Example Dynamic SOQL
String objectName = 'Account';
String fieldName = 'Name';
String query = 'SELECT Id, ' + fieldName + ' FROM ' + objectName + ' LIMIT 10';
List<SObject> results = Database.query(query);

65. Lightning Data Service (LDS)

A framework for accessing and manipulating Salesforce data in Lightning Web Components and Aura components without writing Apex controller code.

Provides automatic caching and sharing of data across components.
Simplifies data access and improves performance.

66. Wire Service (@wire)

A mechanism in Lightning Web Components for efficiently reading Salesforce data or calling Apex methods reactively.

Data fetched via @wire is cached and automatically refreshed when the underlying data changes.
Simplifies data binding in LWC.

// Example using @wire in LWC
import { LightningElement, wire, api } from 'lwc';
import { getRecord, getFieldValue } from 'lightning/uiRecordApi';
import NAME_FIELD from '@salesforce/schema/Account.Name';

export default class AccountDetail extends LightningElement {
    @api recordId;
    @wire(getRecord, { recordId: '$recordId', fields: [NAME_FIELD] })
    account;

    get accountName() {
        return this.account.data ? getFieldValue(this.account.data, NAME_FIELD) : 'Loading...';
    }
}

67. Publish/Subscribe Model (Pub/Sub)

A messaging pattern where senders of messages (publishers) do not send the messages directly to specific receivers (subscribers) but instead categorize published messages into classes without knowledge of which subscribers, if any, there may be.

Used extensively in Platform Events and Lightning Message Service for decoupled communication.

68. Apex Callout Queue

A mechanism for managing asynchronous callouts from Apex, ensuring that they are executed in a controlled and reliable manner, especially in high-volume scenarios.

Helps prevent exceeding callout limits and provides better error handling.
Often used in conjunction with Queueable Apex.

69. Transaction Control (Savepoints and Rollback)

Features in Apex that allow you to define savepoints within a transaction and roll back to a previous state if errors occur, providing more granular control over data changes.

Useful for handling partial failures in complex operations.
Managed using the Database.setSavepoint() and Database.rollback() methods.

70. Change Sets

A declarative tool within the Salesforce Setup menu for packaging and deploying metadata changes between related Salesforce orgs (typically from sandboxes to production).

Suitable for simpler deployments but can become cumbersome for complex projects.
Less robust and lacks version control compared to Salesforce CLI and other deployment tools.

71. Lightning App Builder

A point-and-click tool that allows administrators and developers to create and customize Salesforce pages for Lightning Experience and the Salesforce mobile app without writing code.

Uses a drag-and-drop interface with standard and custom Lightning components.
Enables the creation of App Pages, Home Pages, and Record Pages.

72. Dynamic Forms

A feature within the Lightning App Builder that allows you to place fields anywhere on a record page, control their visibility based on defined criteria, and manage sections dynamically.

Provides greater flexibility and control over the layout of record detail pages.
Reduces the need for multiple page layouts.

73. Dynamic Actions

Similar to Dynamic Forms, but for actions (buttons) on a record page. You can control which actions are visible to users based on specific criteria.

Provides a more contextual and relevant set of actions for users.
Configured within the Lightning App Builder.

74. Salesforce Communities (Experience Cloud)

A platform for creating branded digital experiences connected to your Salesforce data, allowing you to collaborate with customers, partners, and employees.

Offers various templates and customization options.
Supports features like knowledge bases, forums, and customer portals.

75. Salesforce CMS (Content Management System)

Allows you to create, manage, and deliver digital content across various Salesforce channels and external websites or applications.

Supports different content types (text, images, videos).
Integrates seamlessly with Experience Cloud.

76. Salesforce CPQ (Configure, Price, Quote)

A sales tool that helps companies accurately configure product and service bundles, generate accurate quotes, and manage pricing rules.

Automates the quoting process and reduces errors.
Offers features like product configuration, pricing rules, discount schedules, and quote generation.

77. Salesforce Billing

Extends Salesforce CPQ by managing post-sales processes like invoicing, payment processing, and revenue recognition.

Provides a complete quote-to-cash solution.
Automates billing cycles and ensures accurate revenue tracking.

78. Salesforce Service Cloud

A customer service platform built on Salesforce that helps organizations deliver exceptional support experiences.

Offers features like case management, knowledge base, live chat, phone integration (CTI), and self-service portals.
Empowers service agents to resolve issues efficiently.

79. Salesforce Sales Cloud

Salesforce’s core CRM application focused on sales process automation, lead management, opportunity tracking, and sales forecasting.

Provides tools for sales teams to manage their pipelines and close deals effectively.
Includes features like accounts and contacts management, sales stages, and activity tracking.

80. Salesforce Marketing Cloud

A comprehensive digital marketing platform that enables organizations to create and manage personalized marketing campaigns across various channels (email, mobile, social, web).

Offers tools for email marketing, automation, social media engagement, advertising, and data management.
Helps marketers build stronger customer relationships.

81. Omni-Channel

A Service Cloud feature that intelligently routes work items (like cases, chats, leads) to the right agents based on their skills, availability, and priority.

Ensures efficient workload distribution and improves agent productivity.
Provides a unified console for agents to manage work from different channels.

82. Einstein Analytics (Tableau CRM)

A powerful business intelligence and analytics platform integrated with Salesforce, allowing users to explore data, gain insights, and take action directly within the Salesforce workflow.

Offers features like interactive dashboards, data discovery, predictive analytics, and AI-powered insights.

83. Salesforce IoT (Internet of Things) Cloud

A platform for connecting and processing data from connected devices, allowing organizations to gain real-time insights and automate actions based on IoT data.

Enables proactive service, personalized customer experiences, and new business models.

84. Salesforce Mobile SDK

A set of tools and libraries that enable developers to build native and hybrid mobile applications that connect to Salesforce.

Supports iOS, Android, and hybrid development using technologies like React Native and Cordova.
Provides features for authentication, data access, and offline capabilities.

85. Salesforce Integration Patterns

Reusable solutions to common integration challenges between Salesforce and external systems, such as request-reply, fire and forget, batch data synchronization, and remote process invocation.

Understanding these patterns helps in designing robust and scalable integrations.

86. Governor Limits: Asynchronous Apex

Specific governor limits that apply to asynchronous Apex processes like Batch Apex, Queueable Apex, and Future Methods, which are often higher than synchronous limits but still need careful consideration.

Includes limits on the number of queued jobs, batch job execution time, and callouts.

87. Lightning Web Components Open Source (LWCOSS)

The open-source version of the Lightning Web Components framework, allowing developers to build reusable web components that can run on any standards-compliant web platform, not just Salesforce.

Promotes code sharing and reuse across different projects.

88. Salesforce Evergreen

A set of low-code and pro-code development tools and services that allow developers to build and run serverless functions and microservices that integrate with Salesforce.

Includes Salesforce Functions (covered earlier) and other technologies for building scalable backend logic.

89. Salesforce Connect (Custom Adapter)

Allows developers to build custom adapters for Salesforce Connect to access data from external systems that are not supported by the standard adapters (like OData or Cross-Org).

Requires writing Apex code to define how Salesforce interacts with the external data source.

90. Security Assertion Markup Language (SAML)

An open standard for exchanging authentication and authorization data between security domains, often used for implementing Single Sign-On (SSO) with Salesforce.

Allows users to log in to Salesforce using their existing credentials from another identity provider.