Salesforce Integration Specialist Roadmap

1. 1

   Apex and async foundations

   Integrations are built in Apex. You need solid SOQL, DML, collections and async Apex before anything else.

   SOQL and DMLCollections and mapsGovernor limitsQueueable and Batch ApexException handling
   Salesforce Development (Visualforce & Apex) · 5.6h

   About 5.6 hours of video in this step

2. 2

   Authentication and identity

   How systems prove who they are: OAuth flows, connected apps, Named and External Credentials, JWT and single sign-on.

   OAuth 2.0 flowsConnected appsNamed and External CredentialsJWT bearer flowSingle sign-on
   Salesforce Integration Master Course (Advanced Apex) · 27.4h

   About 27.4 hours of video in this step

3. 3

   Outbound: calling other systems

   REST callouts from Apex, serialising and parsing JSON, and handling failures without losing data.

   HttpRequest and HttpResponseJSON serialisationCallouts from QueueableTimeouts and retriesCallouts from Flow
4. 4

   Inbound: other systems calling Salesforce

   The standard REST API, custom Apex REST services, and Bulk API 2.0 for large data volumes.

   REST APIApex REST servicesComposite requestsBulk API 2.0Upserts with external IDs
5. 5

   Event-driven integration

   Publish and subscribe instead of polling: Platform Events, Change Data Capture and the streaming options.

   Platform EventsChange Data CaptureStreaming APIPub/Sub APIReplay and delivery
6. 6

   Testing integrations

   Mock callouts, test Apex REST services and test the failure paths, not just the happy path.

   HttpCalloutMockTesting Apex REST classesSOAP testsNegative testsAsync tests
   Apex Test Fest · 5h

   About 5 hours of video in this step

7. 7

   Patterns, error handling and interviews

   Choose the right integration pattern, design for failure, and explain your choices in an interview.

   Integration patternsIdempotencyError loggingMonitoringInterview practice
   Interview Questions · 3.7h

   About 3.7 hours of video in this step

To become a Salesforce integration specialist, learn in this order: Apex and async foundations, authentication and identity, outbound callouts, inbound APIs, event-driven integration, testing, and finally integration patterns and error handling. If you're already a developer, it usually takes four to seven months part-time in my experience. The timeline above shows the courses for each step. The largest single course, the Integration Master Course, covers most of steps 2 to 5. Below I explain what to practise, what "done" looks like and the traps I see most often.

The time ranges assume around eight to ten hours a week and are from my experience teaching, not measured data.

The roadmap at a glance

Step 1: Apex and async foundations

What to practise: Make sure you can write bulk-safe Apex, build maps from query results and handle exceptions properly. Write a Queueable and a Batch class. If any of that is new, follow the Salesforce developer roadmap first.

Done looks like: You can explain why a callout can't follow uncommitted DML in the same transaction, and how a Queueable gets around it.

Common trap: Starting integration before async Apex. Almost every real integration needs it.

Time: 0 to 2 weeks to refresh if you're a working developer. See the Apex guide and async Apex interview questions.

Step 2: Authentication and identity

What to practise: Create a connected app and authenticate to Salesforce from an outside tool using the OAuth web server flow, then using the JWT bearer flow with a certificate for server-to-server access. Set up a Named Credential backed by an External Credential and use it in a callout. Read how single sign-on works, even if you never configure an identity provider yourself.

Done looks like: Given an integration scenario, you can choose the right OAuth flow and explain why.

Common trap: Relying on the username-password flow because it's easy in a tutorial. Salesforce discourages it, since it means storing a user's password in another system. Learn it so you can recognise it, then use a better flow. Also, be aware that Salesforce now offers External Client Apps as a newer alternative to connected apps; check the current documentation for which to use.

Time: 3 to 5 weeks. The Integration Master Course starts here. See the integration guide.

Step 3: Outbound: calling other systems

What to practise: Call a public REST API from Apex through a Named Credential. Parse the JSON into Apex classes, handle non-200 responses and timeouts, and log failures to a custom object. Make the same call from a Queueable triggered by a record change. Then try an HTTP callout from Flow to see what's possible without code.

Done looks like: When the external system is down, your integration fails gracefully, keeps the data and can retry.

Common trap: Only coding the happy path. Real integrations spend most of their life dealing with failures.

Time: 3 to 4 weeks.

Step 4: Inbound: other systems calling Salesforce

What to practise: Use the standard REST API from an outside tool to create, query and update records. Upsert using an external ID so repeated calls don't create duplicates. Write a custom Apex REST service with @RestResource for a use case the standard API doesn't fit. Load a large file with Bulk API 2.0.

Done looks like: You can choose between the standard REST API, a custom Apex REST service and Bulk API 2.0 for a given volume and use case.

Common trap: Writing custom Apex REST services for things the standard API already does. Each custom endpoint is code you have to test and maintain.

Time: 3 to 4 weeks.

Step 5: Event-driven integration

What to practise: Define a Platform Event, publish it from Apex and subscribe with a trigger. Enable Change Data Capture on an object and watch change events arrive. Learn how subscribers can replay events they missed, and read how external clients subscribe through the Pub/Sub API.

Done looks like: You can explain when to publish an event rather than make a callout, and when Change Data Capture is a better fit than a custom Platform Event.

Common trap: Assuming events are processed instantly and in the same transaction. They aren't. Design for eventual consistency.

Time: 2 to 4 weeks.

Step 6: Testing integrations

What to practise: Write HttpCalloutMock classes for success and failure responses. Test your Apex REST service by setting up RestContext. Test the Queueable that makes the callout.

Done looks like: Your tests cover the failure paths: a 500 response, a timeout and malformed JSON.

Common trap: Mocking only the 200 response. That's the one case you didn't need to test.

Time: 2 to 3 weeks. Apex Test Fest has modules on REST callout tests, REST API class tests and SOAP tests. See Apex testing.

Step 7: Patterns, error handling and interviews

What to practise: Learn the standard patterns: request and reply, fire and forget, batch data synchronisation, remote call-in, UI update based on data changes, and data virtualisation. For each one, design a real example. Make your inbound integrations idempotent so a retried message doesn't create a duplicate.

Done looks like: In an interview, you can take a scenario, pick a pattern, choose the authentication and explain how you'd handle failure.

Common trap: Describing tools instead of trade-offs. Interviewers want to hear why, not just which API.

Time: 2 to 4 weeks, overlapping with your job search. Read Salesforce integration patterns explained and work through the integration interview questions.

A portfolio project that ties it together

Once you've finished the steps, build one integration end to end and put it on GitHub. A good one: an external order system sends new orders into Salesforce through an upsert on an external ID, Salesforce publishes a Platform Event when an order is approved, and an Apex Queueable calls back to the external system through a Named Credential, logging and retrying failures. Write tests for every path, including the failures.

That single project touches authentication, inbound and outbound calls, events, async Apex, idempotency and testing. It's also exactly the kind of scenario integration interviewers like to talk through, so you'll have a real answer instead of a textbook one.