Salesforce Admin to Developer Roadmap

1. 1

   Push Flow to its limits

   You already know the data model. Go deep on Flow first, so you can see exactly where clicks stop and code starts.

   Before-save vs after-save flowsLoops and collections in FlowHTTP callouts from FlowFault pathsFlow Trigger Explorer
   Learn lightning flows with me · 15.9h

   About 15.9 hours of video in this step

2. 2

   Apex, SOQL and DML

   Translate what you know from Flow into code: variables, collections, queries and DML, written in VS Code.

   Variables and collectionsSOQL and relationship queriesDMLGovernor limitswith sharing and user mode
   Salesforce Development (Visualforce & Apex) · 5.6hMastering Visual Studio Code · 2.3h

   About 7.9 hours of video in this step

3. 3

   Triggers and bulkification

   The first real developer skill: triggers that handle a whole batch of records, with logic in a handler class.

   Trigger contextBulk-safe patternsHandler classesOrder of executionTrigger vs Flow on the same object
   Apex Triggers Framework 101 · 0.5h · free

   About 0.5 hours of video in this step

4. 4

   Apex testing

   Every line of Apex needs a test before it can be deployed. Learn to write tests that prove behaviour.

   Test data setupAssert classSystem.runAsNegative testsTesting async code
   Apex Test Fest · 5h

   About 5 hours of video in this step

5. 5

   JavaScript, then Lightning Web Components

   Modern JavaScript first, then components that display data, call Apex and talk to each other.

   Modern JavaScriptGetters, not template expressionsLightning Data ServiceCalling ApexComponent events
   Javascript for Lightning Web Components [FREE] · 2.6h · freeLightning Web Components Development · 7.9h

   About 10.5 hours of video in this step

6. 6

   Async Apex and a first callout

   Queueable, Batch and Scheduled Apex, plus one REST callout using a Named Credential.

   Queueable ApexBatch ApexScheduled ApexNamed CredentialsHTTP callouts
7. 7

   Make the switch

   Take on development work in your current role, then prepare for developer interviews.

   Small dev tickets at workCode reviewsPortfolio projectsInterview practice
   Interview Questions · 3.7h

   About 3.7 hours of video in this step

To move from Salesforce admin to developer, keep your admin foundations and add seven things in order: deeper Flow, Apex with SOQL and DML, triggers and bulkification, testing, JavaScript and Lightning Web Components, async Apex with a first callout, and finally real development work and interview prep. Part-time, most admins I've taught take five to nine months. You're starting ahead of a beginner, because you already understand the data model, security and automation logic. The timeline above lists the courses for each step; below is what to practise, what "done" looks like and the traps admins fall into.

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

The roadmap at a glance

What you already have

Don't underestimate this. You understand objects, relationships, record types, sharing and validation rules. If you've built flows, you already use variables, collections, loops, decisions and fault handling. Apex is largely those same ideas written as code. Most career-changers have to learn the platform and programming at the same time. You only have to learn the programming.

If any of that feels shaky, revisit the admin roadmap first.

What changes is how you work. Admins test changes by clicking through the UI. Developers write code in VS Code, deploy it with the Salesforce CLI, write automated tests and get their work reviewed by other people. Expect the first few weeks to feel slow. That's normal, and it passes once the tools become familiar.

Step 1: Push Flow to its limits

What to practise: Build a record-triggered flow that loops over related records and updates them, then make it fail on purpose with a large data load. Try an HTTP callout from Flow. Use the Flow Trigger Explorer to see everything that runs on one object.

Done looks like: You can point to a requirement and say, "This is where Flow becomes awkward and Apex is cleaner," with a reason.

Common trap: Skipping this because you "already know Flow". Seeing Flow's limits is what makes Apex make sense.

Time: 2 to 3 weeks. See the Flows guide.

Step 2: Apex, SOQL and DML

What to practise: Set up VS Code with the Salesforce extensions. Write Apex that does what one of your flows does: query records, change them in a loop, update them once at the end. Use with sharing by default and query in user mode.

Done looks like: You can rewrite a simple flow as an Apex method that takes a list of records.

Common trap: Learning syntax from slides without typing it. You learn Apex by writing it, hitting compile errors and fixing them.

Time: 6 to 8 weeks. See the Apex guide and SOQL interview questions.

Step 3: Triggers and bulkification

This is where admins most often get caught out. Flow handles bulk processing for you in many cases. In Apex, you handle it yourself.

Here's the pattern to learn. It copies a Region value from each Contact's Account, with one query no matter how many Contacts are saved:

trigger ContactTrigger on Contact (before insert) {
    ContactTriggerHandler.copyAccountRegion(Trigger.new);
}

public with sharing class ContactTriggerHandler {
    public static void copyAccountRegion(List<Contact> contacts) {
        Set<Id> accountIds = new Set<Id>();
        for (Contact c : contacts) {
            if (c.AccountId != null) {
                accountIds.add(c.AccountId);
            }
        }
        if (accountIds.isEmpty()) {
            return;
        }
        Map<Id, Account> accounts = new Map<Id, Account>(
            [SELECT Id, Region__c FROM Account WHERE Id IN :accountIds WITH USER_MODE]
        );
        for (Contact c : contacts) {
            Account parent = accounts.get(c.AccountId);
            if (parent != null) {
                c.Region__c = parent.Region__c;
            }
        }
    }
}

The trigger only delegates. The handler collects IDs first, queries once, then loops. Because it runs before insert, it changes the records directly with no extra DML.

Done looks like: You write every trigger this way without thinking about it, and you know whether a Flow on the same object would conflict with it.

Common trap: Querying inside the loop. It works for one record and fails when someone loads 200. Read Apex bulkification explained.

Time: 2 to 3 weeks. Start with the free Apex Triggers Framework 101 and the triggers interview questions.

Step 4: Apex testing

What to practise: Write a test for the handler above: insert an Account with a Region, insert Contacts, then use Assert.areEqual to check the Region was copied. Add a test with a Contact that has no Account.

Done looks like: Your tests check outcomes and would fail if the logic broke.

Common trap: Treating 75% coverage as the goal. It's the deployment minimum, not a sign of good tests.

Time: 2 to 3 weeks. See Apex testing.

Step 5: JavaScript, then Lightning Web Components

What to practise: Learn modern JavaScript properly first: functions, arrays, objects, promises, async/await and modules. Then build components that show record data, call Apex and send events.

Done looks like: You can build a component that loads data and handles empty and error states, with every computed value in a getter and no expressions in the template.

Common trap: Jumping straight into LWC. Admins who skip JavaScript find LWC confusing for weeks. See learn JavaScript before LWC.

Time: 6 to 8 weeks. Start with the free JavaScript for LWC, then the LWC guide.

Step 6: Async Apex and a first callout

What to practise: Move a slow task into a Queueable, write a small Batch class and schedule it. Then call a public REST API through a Named Credential.

Done looks like: You can say when you'd use Queueable over Batch, and your callout has no hard-coded URL or token.

Common trap: Trying to learn all of integration at once. One clean callout is enough for now. Async Apex is covered in the Apex course; go deeper later with the integration specialist roadmap.

Time: 3 to 4 weeks. See async Apex interview questions.

Step 7: Make the switch

What to practise: Ask for small development tickets at work. Offer to write tests for existing code; it's the fastest way to read a real codebase. Build one portfolio project end to end.

Done looks like: You can explain in an interview why you'd use Flow for one requirement and Apex for another. That judgment is the admin-turned-developer's biggest advantage.

Time: 4 to 6 weeks, overlapping with job searching. The 30-day interview plan helps here, and the full developer roadmap shows what comes next.