Salesforce Integration Masterclass: Beginner to Advanced

Learn how integration coordinates systems: a source sends a request via an API to Salesforce, which processes data, executes business logic, and returns a response.

Explore authentication, authorization, and access tokens in Salesforce integrations, and learn how OAuth secures API requests with flows such as authorization-based, user-based, JWT based, and client credential flow.

Explore the REST and SOAP APIs, comparing JSON-based REST with XML-based SOAP, their HTTP methods, client-server flow, and when to use each for secure, scalable Salesforce integrations.

Master the rest api building blocks - endpoints, http methods, headers, and request and response bodies with status codes - and compare json and xml formats for Salesforce integration.

Describe inbound and outbound integration directions in Salesforce, where the system either receives data from external apps via REST APIs, SOAP API, and bulk APIs, or sends data to them.

Learn how to choose between synchronous real-time integration and asynchronous background processing, using examples like website to Salesforce and ERP data flows to balance immediate responses with bulk data handling.

Express gratitude for choosing the course and invite learners to share their reviews in the comment section, highlighting how feedback fuels growth and helps others understand their learning experience.

Explore how the external client app serves as the next-generation security gateway between Salesforce and third-party apps, using OAuth, second-generation packaging, and configurable metadata.

Connect Postman with Salesforce to test APIs and OAuth flows, clone the Salesforce platform APIs collection, set up a workspace, and validate with a sample get request.

Discover how the Salesforce platform REST API enables external systems to create, read, update, delete, and query data via HTTP endpoints using JSON and OAuth access tokens.

Explore the Salesforce platform rest api with Postman, authenticate, access endpoints, and perform create and soql query operations on sobjects.

Expose Apex classes as rest resources using annotations to create endpoints for external apps to access Salesforce logic via http methods like get, post, patch, and delete.

Build your first apex rest service by creating a global class, defining a rest resource and the http get method, and testing the endpoint with postman.

Perform an http post to the accounts endpoint to create an account in Salesforce from an external lead capture site, mapping the json body to parameters and validating the name.

Implement a patch operation to update Salesforce opportunities by reading the url id, accepting a patch request wrapper with stage name and amount, and returning a json response.

Post to the case management REST API with an outer request containing an inner case object, including subject, description, priority, origin, and return a success response with case data.

practice a patch-based partial update for a case, using the case ID URL and a two-field body, with wrapper class or parameter options, and invoke patch; validate via GitHub.

Explore deleting a case via a rest api endpoint using the delete method, including id validation, a delete operation, error handling, and testing the Apex rest service.

Learn how to write a test class for an Apex REST service by mocking the REST context, creating a fake REST request and response, and validating behavior.

Learn to build a hands-on Apex rest test class for a case management rest service, create test data, configure rest context, run as the current user, and assert case found.

Develop and test an Apex REST post method by constructing a case request with subject, description, priority, and origin, validating success and the case ID.

Explore how Apex callouts let Salesforce talk to external systems via synchronous and asynchronous http calls, covering endpoints, methods, headers, bodies, and key governor limits.

Understand the golden rule: no callout after DML in the same transaction. Split into two transactions or call out before DML using future, queueable, batch, or schedulable Apex.

Master the three Apex callout classes — HTTP request, HTTP, and HTTP response — and learn the universal skeleton, endpoint, method, headers, body, timeout, and the 200–299 status flow.

Learn to parse json responses in Apex by deserializing into a wrapper class or via untyped maps or lists, and use json to Apex tools to generate it.

Build a trimmed Apex wrapper that parses JSON exchange rates, extracting GBP and Euro with a static parse method in Salesforce.

Learn untyped deserialization with json.deserializeUntyped by mapping json into a map of string to object, casting values, and choosing between typed and untyped approaches.

Explore named credentials and external credentials in Salesforce's modern three-layer stack, enabling secure authentication, centralized credential management, and keeping credentials out of Apex code.

Explore the three-layer modern authentication stack—name credential, external credential, and permission set mapping—and see how Apex callouts resolve base URLs, authentication protocols, and principles securely.

Configure a custom authentication protocol for an API key, create external credential and principle, map the API key header, and set up a name credential for the Ninja API.

Build an Apex class to perform api key authentication via a name credential, construct dynamic category endpoints with url encoding, and parse json responses from the quote api.

Build a Salesforce Jira integration using basic authentication by posting cases as Jira issues, covering endpoint setup, request body creation, headers, JSON serialization, and response handling.

Understand how OAuth enables limited, credential-free access to user resources through delegation, scope, and consent, and explore the differences and capabilities of OAuth 2.0.

Understand the core OAuth 2.0 terminology, including consumer key and secret, access and refresh tokens, bearer token, scope, and consent. This beginner-friendly guide builds a solid foundation before practical implementation.

Explore how OAuth 1.0 and OAuth 2.0 differ in flow and token management, with a consent-based example of accessing protected resources via an authorization server and resource server.

Explore the OAuth 2.0 client credentials flow, where an app authenticates with a client ID and secret without user involvement to obtain a bearer token in four steps.

Learn how to implement a Salesforce to Salesforce integration using the client credential flow across two developer orgs, focusing on the integration user, audit trails, and free API-only licenses.

Implement the end-to-end client credentials flow between org A and org B, configuring external and name credentials, permission set mapping, and a connected app with an integration user.

Explore hands-on setup of the client credentials flow in Salesforce by creating integration users, configuring an external client app, and enabling oauth policies for secure app access.

Learn to fetch records from a second Salesforce org by writing an Apex class that uses a client credential flow, a name credential, and a REST query to retrieve accounts.

Learn the oauth 2.0 jwt bearer flow, how signing with a private key creates a verifiable token (header, payload, signature) without exposing a secret.

Learn step-by-step JWT bearer flow implementation between two Salesforce orgs, sending a signed assertion via a token endpoint using certificate-based authentication, with issuer, subject, audience, and five-minute expiry.

Master jwt bearer flow setup in Salesforce by creating a self-signed certificate with OpenSSL, generating and converting keys to JKS, and configuring certificate management and external client app.

Demonstrate the end-to-end jwt bearer flow from org A to org B using a name credential and jwt service to fetch 10 records with a 200 response.

Explore how Salesforce auth providers enable browser-based oauth with login, consent, redirects, and token exchange, and differentiate them from external credentials using per user principal and named principal concepts.

Discover how the oauth 2.0 pkce flow enhances the authorization code flow with a code verifier and a code challenge using SHA-256 to prevent token interception in Salesforce.

Compare all OAuth 2.0 flows, including client credential, JotBearer, authorization code, and PXE. Apply a decision framework to choose the right flow by user involvement and security needs.

Learn to trigger asynchronous http callouts from a record-triggered flow to create a case in a secondary org when an account becomes inactive, using name credentials and the sobject api.

Learn how to test http callouts in salesforce with an http callout mock to return fake responses. Register the mock with test.setMock to avoid real calls.

Master enterprise error handling for Salesforce integrations: define error categories (client, server, rate limit, timeout), implement retry with exponential backoff, and robust logging with try-catch and wrapper classes.

Enable persistent integration logging with a custom integration log object to capture endpoint, request and response details, errors, timestamps, and affected records for fast debugging and auditing.

Learn best practices for Salesforce callouts, including a three-layer architecture, service classes, robust error logging, controlled retries, timeout management, bulk processing, and thorough testing to build observable, secure, resilient integrations.

Explore bulk api 2.0 for high-volume data operations, including CSV uploads up to 150 MB, automatic batch splitting, and a simple job lifecycle of create, upload, close, and polling.

Master the bulk api 2.0 job lifecycle, from creating a job and uploading csv data (multiple files supported) to closing the job and polling status for results.

Adjust polling frequency by job size with exponential back off for bulk API; acknowledge partial success, abort does not roll back processed records, and consider all-or-none up to 200 records.

Master CSV formatting for Salesforce Bulk API 2.0: header uses API names, line endings. Use external IDs for upsert and within limits: 150 MB upload, 10 MB row, 300 fields.

Learn how bulk API 2.0 delivers high throughput with far fewer API calls than REST, and master limits, automation impact on throughput, and best practices for scalable data loading.

Compare streaming API and REST API, noting push-based real-time delivery, event bus routing from publishers to subscribers, replay IDs, and retention for platform events and change data capture.

Create a platform event for error logging with publish immediately, enabling error handling across Apex, Flow, and integrations, and subscribe to log errors into a custom object with admin alerts.

Install and use Salesforce streaming monitor, a free app exchange tool, to track platform events and change data capture, view payloads, and troubleshoot in real-time.

Learn to publish platform events with Apex using eventbus.publish, handle results and errors, and bulk publish while tracking replay IDs and DML limits.

Publish platform events from a no-code flow using the create record element on the platform event object, set fields, and publish after the record triggers. Experiment with screen flows, record-triggered flows, scheduled flows, auto-launch flows, and platform event triggered flows, while avoiding before-record publish and using after-record publish for events.

Publish platform events to Salesforce from external systems using rest api and composite api, sending post requests with valid access tokens and json bodies, and tracking via replay ids.

Learn how the platform event bus publishes events, assigns replay IDs, and delivers to Apex triggers, Flow, and LWC components, each in its own transaction.

Learn to subscribe to a platform event using an Apex trigger, handling after insert events, managing async governor limits, with 2000 batch size, and logging errors into an integration log.

Learn to write a test class for platform event triggers by publishing events via the event bus between test start and stop to run synchronously and validate integration log results.

Discover how to subscribe to platform events in Salesforce using the platform event triggered flow, compare it with record triggered flows, and observe async processing.

Subscribe to platform events in a Lightning Web Component using the EMP API, handling subscribe, unsubscribe, onEvent, and onError, and display real-time error logs in a data table.

Explore change data capture (cdc) in Salesforce, compare it with platform events, and learn how cdc automatically publishes change events for real-time data synchronization and audit trails.

Master Salesforce CDC naming conventions for standard and custom objects, and understand the event message structure with header, body, and metadata, including change types, fields, and nullified fields.

Discover how to subscribe to change data capture with Apex triggers, using the events pattern, and implement a trigger that creates a follow-up task when account active changes to no.

subscribe to change data capture events with lightning web components in salesforce, using the EMP API, proper cdc channel names, and handling create, update, delete, and undelete events.

Master Salesforce change data capture best practices and limitations. Identify what triggers CDC, payload nuances for compound fields, and security implications for EMP API and integration users.

Explore Salesforce Connect and external objects to view live data in Salesforce without duplication and with zero storage cost, using OData queries, external data sources, and adapters for real-time access.

Explore OData protocol behind Salesforce Connect, translating SOQL into HTTP GET requests with filter, sorting, and pagination, and compare OData 2.0 and 4.0 formats (XML vs JSON) for data sources.

Configure the cross org adapter to connect two Salesforce orgs without data copy, using rest api to surface external objects like cases and accounts in real time via Salesforce connect.

Learn how external IDs link external objects to Salesforce records with external lookup and indirect lookup relationships, and understand their indexing and 25-per-object limit.

Connect two Salesforce orgs with Salesforce Connect, link external objects via an indirect lookup relationship, and surface service org cases in the sales org using a shared external id.

Explore Salesforce Connect best practices, limitations, and considerations, including external object querying with limits, HTTP callouts, restricted aggregates and subqueries, and performance guidelines for related lists and security.

Learn how continuation enables long running callouts in Apex without blocking threads, reducing timeouts and boosting scalability, via a two-phase initiation and callback lifecycle for UI driven integrations.

Enable parallel HTTP callouts with continuation to run up to three requests in parallel, and fire a single callback once all responses arrive, with a 120-second timeout.

Chain continuations to run dependent callouts, such as computing a credit score before generating an insurance quote, using the state parameter to pass data between steps.