Learn Salesforce Integration: REST, OAuth, Named Credentials, Platform Events and Bulk API

To learn Salesforce integration, you need four skills on top of solid Apex: authentication (OAuth flows, JWT, connected apps and Named Credentials), outbound REST callouts from Apex, inbound APIs such as REST, Bulk API 2.0 and Metadata API, and event-driven integration with platform events and streaming. The Integration Master Course above covers all of it. It's the largest course in the catalogue at 27 hours, and every integration is built live, with real tokens, real failures and real debugging.

What Salesforce integration is and where you use it

Very few Salesforce orgs live alone. On real projects, integration work looks like:

• Outbound calls. Salesforce calls an ERP to check stock, a payment gateway to take a payment, or a tax service to price a quote.
• Inbound calls. An external system creates or updates records in Salesforce through the REST API, or through a custom Apex REST endpoint you write.
• High-volume sync. A data platform loads or extracts large volumes nightly through Bulk API 2.0.
• Event-driven messaging. Salesforce publishes platform events that external subscribers react to, or consumes events from them, so the systems aren't tightly coupled.
• Identity. Single sign-on so users log in once across systems.
• Tooling. Metadata and Tooling API work for deployment and developer tools.

The patterns behind these choices are explained in Salesforce integration patterns.

Prerequisites

• Solid Apex, including collections and async Apex (future methods and Queueable). See the Apex guide.
• Test classes, because every callout needs a mock. See Apex testing.
• HTTP and JSON basics. Methods, status codes, headers and request and response bodies.
• A tool for calling APIs, such as Postman or curl, to test inbound calls.

What you'll be able to build afterwards

• Apex REST callouts that authenticate through Named and External Credentials, with no secrets in code
• A connected app and an OAuth flow suited to each scenario, including JWT bearer for server-to-server
• Custom Apex REST services that external systems call
• Publish and subscribe integrations with platform events
• Bulk API 2.0 jobs for loading and extracting data at volume
• Tests that mock every callout, success and failure

A hands-on example: a callout through a Named Credential

Requirement: fetch an exchange rate from an external service. The endpoint and authentication live in a Named Credential called Exchange_Rates, so the code never sees a URL or an API key.

public with sharing class ExchangeRateService {
    public class ExchangeRateException extends Exception {}

    public class RatesResponse {
        public Map<String, Decimal> rates;
    }

    public static Decimal getRate(String fromCurrency, String toCurrency) {
        HttpRequest req = new HttpRequest();
        req.setEndpoint('callout:Exchange_Rates/latest?base=' + EncodingUtil.urlEncode(fromCurrency, 'UTF-8'));
        req.setMethod('GET');
        req.setTimeout(10000);

        HttpResponse res = new Http().send(req);
        if (res.getStatusCode() != 200) {
            throw new ExchangeRateException('Rate service returned HTTP ' + res.getStatusCode());
        }

        RatesResponse parsed = (RatesResponse) JSON.deserialize(res.getBody(), RatesResponse.class);
        if (parsed.rates == null || !parsed.rates.containsKey(toCurrency)) {
            throw new ExchangeRateException('No rate returned for ' + toCurrency);
        }
        return parsed.rates.get(toCurrency);
    }
}

The details that matter:

• callout:Exchange_Rates makes Salesforce resolve the base URL and add authentication from the Named Credential and its External Credential. Admins can point sandboxes and production at different endpoints without changing code, and you don't need a separate Remote Site Setting.
• The input is URL-encoded, so unexpected characters can't break or alter the request.
• An explicit timeout. Don't rely on the default when a slow API could hold up a user.
• The status code is checked before the body is parsed. A 500 response with an HTML error page would otherwise fail in confusing ways.
• Typed deserialisation into RatesResponse is clearer and safer than casting through untyped maps.
• A custom exception lets callers decide what to do: retry, log or show a message.

In the course, the next step is the test: an HttpCalloutMock that returns a 200 response, another that returns a 500, and assertions for both.

Common mistakes beginners make

1. Hard-coding endpoints and secrets in Apex, custom settings or custom labels. Use Named and External Credentials.
2. Calling out after DML in the same transaction. Salesforce blocks a callout after uncommitted DML with a "You have uncommitted work pending" error. Make the callout first, or move it to async Apex.
3. Calling out directly from a trigger. Triggers can't make synchronous callouts. Use a Queueable that implements Database.AllowsCallouts, or a future method with callout=true.
4. Using the username-password OAuth flow in production. It's useful for learning the mechanics but needs a stored password. Prefer JWT bearer or client credentials for system integrations.
5. Ignoring volume. Record-by-record REST calls for large data loads waste API limits. Use Bulk API 2.0.
6. No error handling or logging. External systems fail. Decide what happens on a timeout, a 4xx or a 5xx before you go live.
7. Untested callouts. Tests can't make real callouts, so untested integration code usually means untested code.

How integration connects to the other topics

• It's built on Apex and Apex testing. Async Apex in particular is essential, and async Apex interview questions cover it.
• Salesforce Flows can make HTTP callouts and react to platform events, so admins and developers often share integration work.
• LWC components often display data that arrives through an integration.
• The full path is in the Salesforce integration specialist roadmap. For interviews, see Salesforce integration interview questions.

Who should skip this

• Skip it if you're still learning Apex basics. Come back once you can write a bulk-safe trigger and a Queueable with tests.
• Skip it if you're an admin who only needs point-and-click connections. The Flow course covers HTTP callouts from Flow.
• Skip the authentication modules if you already run OAuth and JWT integrations in production, and go straight to platform events, Bulk API 2.0 and Metadata API.

There are no refunds, so judge the teaching with a free course first. Apex Triggers Framework 101 is the closest free course to this style of work.