4-Week Salesforce PDI (Platform Developer I) Learning Plan

This plan uses the Pomodoro Technique (25-minute focused study blocks) and Ebbinghaus Forgetting Curve principles (spaced review) to help you master the PDI content. It provides clear goals, tasks, and detailed activities for every study day.

Week 1: Developer Fundamentals

Goal: Build a strong foundation in Salesforce data modeling, Apex programming, and SOQL.

Day 1: Understanding Salesforce Data Modeling

Objectives:

• Learn about Standard Objects (e.g., Account, Contact, Opportunity).
• Understand Schema Builder to visualize and design data models.

Tasks:

1. Study what Standard Objects are and their use cases.
   • Example: Learn how Account relates to Contact.
   • Read Salesforce documentation on Standard Objects.
2. Open Schema Builder in a Developer Org or Sandbox:
   • Explore relationships between Account and Opportunity.
   • Add a custom object (e.g., Student__c).
3. Hands-on Practice:
   • Design a schema for a Student Management System:
     • Student__c (Custom Object).
     • Fields: Name, Grade (Picklist), Enrollment Date (Date).
4. Create notes summarizing:
   • Differences between Lookup and Master-Detail relationships.

Day 2: Learning Field Types

Objectives:

• Learn about Salesforce field types: scalar, formula, and relationship fields.
• Practice creating fields and understanding their behavior.

Tasks:

1. Scalar Fields:
   • Create fields of type Text, Number, and Date in a custom object.
   • Test by adding records in Salesforce.
2. Formula Fields:
   • Create a formula field in Student__c:
     • Formula: TODAY() - Enrollment Date.
     • Purpose: Calculate the number of days since enrollment.
3. Relationship Fields:
   • Create a Master-Detail relationship between Student__c and a custom object Class__c.
   • Create a Lookup relationship between Class__c and Teacher__c.
4. Test in the User Interface:
   • Create records and verify the relationships.
5. Review differences between Lookup and Master-Detail relationships.

Day 3: Introduction to Apex Programming

Objectives:

• Understand Apex basics: variables, loops, and control statements.
• Write simple Apex classes to perform calculations.

Tasks:

1. Learn Syntax:

   • Study how to declare variables (String, Integer, Boolean).
   • Learn loops (for, while) and conditionals (if-else).

2. Practice in Developer Console:

   • Write a simple Apex snippet to calculate a discount:

     Integer price = 100;
     Integer discount = 20;
     Integer finalPrice = price - discount;
     System.debug('Final Price: ' + finalPrice);
     

3. Write an Apex Class:

   • Create a class DiscountCalculator:
     • Method: calculateDiscount(price, discountPercentage).
     • Test it in Developer Console.

4. Summarize key Apex concepts in notes.

Day 4: Learning SOQL Basics

Objectives:

• Understand SOQL (Salesforce Object Query Language) to retrieve data.
• Write basic and advanced queries.

Tasks:

1. Basic SOQL Queries:

   • Query Account records:

     SELECT Id, Name FROM Account WHERE Industry = 'Technology'
     

   • Test in Developer Console.

2. Filters and Sorting:

   • Query Contact records sorted by LastName:

     SELECT Id, FirstName, LastName FROM Contact ORDER BY LastName ASC
     

3. Nested Queries:

   • Query parent-child relationships:

     SELECT Name, (SELECT LastName FROM Contacts) FROM Account
     

4. Hands-on:

   • Write and test 5 queries for your custom objects.

Day 5: Writing Triggers

Objectives:

• Understand Trigger syntax and lifecycle (Before and After events).
• Write a basic Trigger to automate field updates.

Tasks:

1. Learn Trigger Syntax:

   • Understand Trigger.new and Trigger.old.

2. Write a Trigger:

   • Automate Student__c updates:

     • Before Insert: Automatically populate the Grade field based on the Age field.

   • Example:

     trigger StudentTrigger on Student__c (before insert) {
        for (Student__c student : Trigger.new) {
            if (student.Age < 10) {
                student.Grade = 'Elementary';
            }
        }
     }
     

3. Test the Trigger by inserting records in Salesforce.

Day 6: Consolidation

Objectives:

• Review all Week 1 topics: Data Modeling, SOQL, Apex, and Triggers.
• Solve practice questions and Trailhead challenges.

Tasks:

1. Revisit:
   • Schema Builder.
   • Apex syntax and examples.
2. Practice:
   • Solve Trailhead challenges on SOQL and Triggers.
   • Write 3 SOQL queries for custom objects.
3. Review notes using flashcards.

Day 7: Review and Active Recall

Objectives:

• Ensure all Week 1 concepts are clear.
• Identify weak areas for further study.

Tasks:

1. Create a mind map summarizing:
   • Standard vs. Custom Objects.
   • Field Types.
   • SOQL basics.
   • Apex syntax.
2. Quiz yourself:
   • Use flashcards or write down key questions (e.g., What is Trigger.new?).
3. Rest and prepare for Week 2.

Here’s the detailed week-by-week learning plan for Salesforce PDI. Each week will follow the format used for Week 1, with clear objectives, tasks, and activities.

Week 2: Process Automation and Logic

Goal: Understand declarative automation tools like Process Builder and Flows, and master programmatic automation with triggers and asynchronous Apex.

Day 1: Learn Process Builder Basics

Objective:

• Understand what Process Builder is and how it helps automate simple business logic.

Tasks:

1. Introduction to Process Builder:

   • Learn its purpose and when to use it instead of Flows or Triggers.
   • Explore Process Builder in Setup > Process Automation > Process Builder.

2. Hands-on Task:

   • Create a Process to update the Account’s Status field:
     • Triggered when an Opportunity is marked as "Closed Won."
     • Action: Update the related Account's Status field to "Active."

3. Test the Process:

   • Create test records in the sandbox to ensure the Process updates fields correctly.

4. Write notes summarizing:

   • Advantages of Process Builder.
   • Comparison with Flows and Triggers.

Day 2: Explore Flow Builder

Objective:

• Learn how to create more complex workflows using Flow Builder.

Tasks:

1. Introduction to Flow Builder:

   • Study its capabilities: Loops, decisions, and dynamic forms.
   • Open Flow Builder: Setup > Process Automation > Flows.

2. Hands-on Task:

   • Build a Flow that:
     • Takes input from a user (e.g., Customer Feedback).
     • Checks if the feedback score is below 3.
     • Sends an automated email to a customer service team if the score is low.

3. Test the Flow:

   • Simulate feedback submission and validate the email trigger.

4. Write notes summarizing:

   • Types of Flows (Screen, Record-Triggered, and Scheduled Flows).
   • When to choose Flows over Process Builder or Apex.

Day 3: Work with Approval Processes

Objective:

• Learn to automate multi-step approval workflows.

Tasks:

1. Introduction to Approval Processes:

   • Study how approvals work and their use cases.
   • Open Approval Processes: Setup > Approval Processes.

2. Hands-on Task:

   • Create an Approval Process for a custom object (Discount Request__c):
     • Step 1: Manager reviews the discount request.
     • Step 2: Director approves discounts above 20%.

3. Test the Approval Process:

   • Submit test records and verify approval notifications.

4. Write notes summarizing:

   • Steps in creating Approval Processes.
   • Differences between Approvals, Flows, and Process Builder.

Day 4: Understand Triggers and Future Methods

Objective:

• Explore how programmatic automation works with triggers and asynchronous Apex.

Tasks:

1. Review Trigger Basics:

   • Revisit the structure of triggers (Before and After events).
   • Learn about Trigger.new and Trigger.oldMap.

2. Hands-on Task:

   • Write a Trigger on Contact:

     • Action: Automatically create a Task when a new Contact is created.

   • Example:

     trigger ContactTrigger on Contact (after insert) {
        for (Contact con : Trigger.new) {
            Task t = new Task();
            t.Subject = 'Follow up with ' + con.FirstName;
            t.WhatId = con.Id;
            t.Status = 'Not Started';
            insert t;
        }
     }
     

3. Future Methods:

   • Learn the purpose of Future methods (asynchronous operations).

   • Write a Future method to send emails:

     @future
     public static void sendEmail(String email) {
        // Logic to send email
        System.debug('Email sent to ' + email);
     }
     

4. Test the Trigger and Future Method:

   • Create a Contact and verify that a Task is created and an email is logged.

Day 5: Work with Batch Apex

Objective:

• Understand how to handle large data volumes using Batch Apex.

Tasks:

1. Learn Batch Apex Basics:

   • Understand the structure: start, execute, finish.

2. Hands-on Task:

   • Write a Batch Apex class to clean up inactive Accounts:

     • Query all inactive Accounts.
     • Update their Status to "Archived."

   • Example:

     global class BatchAccountArchiver implements Database.Batchable<sObject> {
        global Database.QueryLocator start(Database.BatchableContext context) {
            return Database.getQueryLocator('SELECT Id, Status FROM Account WHERE Status = \'Inactive\'');
        }
        global void execute(Database.BatchableContext context, List<Account> scope) {
            for (Account acc : scope) {
                acc.Status = 'Archived';
            }
            update scope;
        }
        global void finish(Database.BatchableContext context) {
            System.debug('Batch job completed.');
        }
     }
     

3. Test the Batch Job:

   • Execute it using Database.executeBatch(new BatchAccountArchiver());.

4. Write notes on:

   • Use cases for Batch Apex.
   • Differences between Batch Apex and Future Methods.

Day 6: Learn Queueable Apex and Scheduled Jobs

Objective:

• Explore advanced asynchronous techniques like Queueable Apex and Scheduled Jobs.

Tasks:

1. Queueable Apex:

   • Study how Queueable Apex allows for chaining operations.

   • Hands-on: Write a Queueable class to calculate discounts for multiple records.

   • Example:

     public class DiscountProcessor implements Queueable {
        public void execute(QueueableContext context) {
            List<Account> accounts = [SELECT Id, Name FROM Account WHERE Industry = 'Retail'];
            for (Account acc : accounts) {
                acc.Discount__c = 10;
            }
            update accounts;
        }
     }
     

   • Execute with:

     System.enqueueJob(new DiscountProcessor());
     

2. Scheduled Jobs:

   • Learn how to schedule recurring tasks.

   • Write a job to send weekly reminders for overdue tasks:

     global class TaskReminderJob implements Schedulable {
        global void execute(SchedulableContext sc) {
            List<Task> overdueTasks = [SELECT Id, Subject FROM Task WHERE Status = 'Not Started' AND DueDate < TODAY];
            for (Task t : overdueTasks) {
                System.debug('Reminder: ' + t.Subject);
            }
        }
     }
     

   • Schedule it:

     String cron = '0 0 12 * * ?'; // Noon daily
     System.schedule('Weekly Task Reminder', cron, new TaskReminderJob());
     

3. Test both Queueable Apex and Scheduled Jobs.

Day 7: Review and Practice

Objective:

• Consolidate Week 2 concepts.
• Solve practice problems and refine weak areas.

Tasks:

1. Revise:
   • Process Builder, Flows, Approval Processes.
   • Triggers, Batch Apex, Queueable Apex, and Scheduled Jobs.
2. Solve Trailhead Challenges:
   • Focus on Process Automation and Asynchronous Apex modules.
3. Mock Exam:
   • Attempt questions related to automation tools.
4. Summarize:
   • Write flashcards for the key concepts.

Week 3: User Interface

Goal: Master the creation of user interfaces using Visualforce and Lightning Web Components (LWC). Learn to optimize UI for user experience and performance.

Day 1: Introduction to Visualforce

Objective:

• Understand the basics of Visualforce and how to create pages using <apex> components.

Tasks:

1. Learn Visualforce Basics:

   • Study the purpose and structure of Visualforce.
   • Key Tags: <apex:page>, <apex:form>, <apex:inputText>.

2. Hands-on Task:

   • Create a Visualforce page:

     • Input a Contact’s First Name and Last Name.
     • Display a confirmation message upon submission.

   • Example:

     <apex:page>
        <apex:form>
            <apex:inputText label="First Name" value="{!firstName}" />
            <apex:inputText label="Last Name" value="{!lastName}" />
            <apex:commandButton value="Submit" action="{!submit}" />
        </apex:form>
     </apex:page>
     

3. Test:

   • Open the page in Salesforce and test the form functionality.

4. Summarize:

   • Write notes on how <apex> components work.

Day 2: Custom Controllers in Visualforce

Objective:

• Learn how to link Apex controllers with Visualforce pages to dynamically control data.

Tasks:

1. Understand Custom Controllers:

   • Study how Apex controllers interact with Visualforce pages.
   • Learn about getter and setter methods.

2. Hands-on Task:

   • Create a custom controller to fetch Account data dynamically:

     • Add a search box to find Accounts by Name.
     • Display results in a table.

   • Example: Visualforce Page:

     <apex:page controller="AccountController">
        <apex:form>
            <apex:inputText value="{!searchTerm}" label="Search Account" />
            <apex:commandButton value="Search" action="{!searchAccounts}" />
        </apex:form>
        <apex:pageBlock>
            <apex:pageBlockTable value="{!accounts}" var="acc">
                <apex:column value="{!acc.Name}" />
                <apex:column value="{!acc.Industry}" />
            </apex:pageBlockTable>
        </apex:pageBlock>
     </apex:page>
     

     Custom Controller:

     public class AccountController {
        public String searchTerm { get; set; }
        public List<Account> accounts { get; set; }
     
        public void searchAccounts() {
            accounts = [SELECT Name, Industry FROM Account WHERE Name LIKE :('%' + searchTerm + '%')];
        }
     }
     

3. Test:

   • Search for an Account and verify the results.

4. Summarize:

   • Write notes comparing standard and custom controllers.

Day 3: Introduction to Lightning Web Components (LWC)

Objective:

• Understand the structure and basics of LWC development.

Tasks:

1. Learn LWC Basics:

   • Study the three main files of an LWC component:
     • HTML Template: UI structure.
     • JavaScript Controller: Logic and interactivity.
     • CSS (optional): Styling.

2. Hands-on Task:

   • Create a simple LWC that displays a greeting message:

     • Input: User's name.
     • Output: "Hello, [Name]!"

   • Example: HTML:

     <template>
        <lightning-card>
            <lightning-input label="Enter your name" onchange={handleNameChange}></lightning-input>
            <p>Hello, {name}!</p>
        </lightning-card>
     </template>
     

     JavaScript:

     import { LightningElement } from 'lwc';
     export default class GreetingComponent extends LightningElement {
        name = '';
        handleNameChange(event) {
            this.name = event.target.value;
        }
     }
     

3. Test:

   • Deploy the component to a Salesforce org and add it to a Lightning App Page.

4. Summarize:

   • Write notes on the key differences between LWC and Visualforce.

Day 4: Advanced LWC Features

Objective:

• Learn how to handle events and communicate between components in LWC.

Tasks:

1. Learn Event Handling:

   • Understand how to handle button clicks and input changes using JavaScript.

2. Hands-on Task:

   • Build a parent-child LWC:

     • Parent component passes a value to the child component.
     • Child component emits an event to the parent.

   • Example: Child Component JavaScript:

     import { LightningElement, api } from 'lwc';
     export default class ChildComponent extends LightningElement {
        @api message;
        handleClick() {
            this.dispatchEvent(new CustomEvent('customclick', { detail: 'Child Clicked!' }));
        }
     }
     

     Parent Component JavaScript:

     import { LightningElement } from 'lwc';
     export default class ParentComponent extends LightningElement {
        messageFromChild = '';
        handleCustomClick(event) {
            this.messageFromChild = event.detail;
        }
     }
     

3. Test:

   • Deploy both components and verify their interaction.

4. Summarize:

   • Write notes on event handling in LWC.

Day 5: User Experience Optimization

Objective:

• Learn how to improve UI performance and user experience.

Tasks:

1. Dynamic Forms:

   • Learn how to create forms that show or hide fields based on user input.
   • Hands-on: Create a dynamic form for Case objects.

2. Performance Optimization:

   • Study techniques for optimizing LWC:
     • Use @wire for data fetching.
     • Minimize SOQL queries in Apex.
   • Test: Compare loading times for optimized vs. unoptimized components.

3. Summarize:

   • Write notes on best practices for dynamic forms and performance.

Day 6: Consolidation

Objective:

• Review all UI concepts and solve practice problems.

Tasks:

1. Revisit:
   • Visualforce tags and controllers.
   • LWC components and event handling.
2. Practice:
   • Build a small project combining Visualforce and LWC:
     • Use Visualforce to display existing data.
     • Use LWC for interactive functionality.
3. Solve Trailhead challenges on Visualforce and LWC.

Day 7: Review and Mock Exam

Objective:

• Assess understanding of UI concepts and refine weak areas.

Tasks:

1. Revise:
   • Flashcards on Visualforce and LWC key concepts.
   • Notes on dynamic forms and optimization.
2. Mock Exam:
   • Take a UI-specific practice test.
3. Summarize:
   • Write down areas needing improvement and revisit them.

Week 4: Testing, Debugging, and Deployment

Goal: Master Salesforce testing requirements, debugging tools, and deployment strategies while preparing for the final exam with mock tests.

Day 1: Understanding Unit Testing

Objective:

• Learn to write unit tests for Apex classes and triggers.
• Understand Salesforce's 75% code coverage requirement.

Tasks:

1. Study Unit Testing Basics:

   • Review Salesforce testing principles:
     • Test data isolation.
     • Validation using System.assert.
     • Test coverage goals (≥75%).

2. Write a Test Class:

   • Test a trigger that updates Account.Description when a new Contact is created.

   • Example Test Class:

     @isTest
     public class AccountTriggerTest {
        @isTest
        static void testContactTrigger() {
            Account acc = new Account(Name = 'Test Account');
            insert acc;
     
            Contact con = new Contact(FirstName = 'Test', LastName = 'Contact', AccountId = acc.Id);
            insert con;
     
            Account updatedAcc = [SELECT Description FROM Account WHERE Id = :acc.Id];
            System.assertEquals('Contact Added', updatedAcc.Description);
        }
     }
     

3. Validate:

   • Run the test in Developer Console and check the coverage.

4. Summarize:

   • Note key components of a test class (setup, execution, assertions).

Day 2: Debugging Apex Code

Objective:

• Use Salesforce debugging tools to analyze and optimize code.

Tasks:

1. Study Debugging Basics:

   • Learn about log levels (Debug, Error, Info).
   • Explore the Developer Console’s Debug Logs feature.

2. Hands-on Task:

   • Create an Apex class with a bug (e.g., incorrect SOQL query).

   • Use System.debug() to log variable values and identify the issue.

     public class DebugExample {
        public static void debugAccounts() {
            List<Account> accounts = [SELECT Id FROM Account WHERE Industry = null]; // Intentional bug
            System.debug('Accounts: ' + accounts);
        }
     }
     

3. Fix the Bug:

   • Update the SOQL query to handle null values correctly.

4. Summarize:

   • Write notes on effective debugging practices:
     • Use meaningful System.debug() statements.
     • Filter logs to focus on relevant issues.

Day 3: Working with Change Sets

Objective:

• Learn how to migrate metadata between environments using Change Sets.

Tasks:

1. Understand Change Sets:

   • Study what metadata can be included in Change Sets.
   • Learn about Outbound and Inbound Change Sets.

2. Hands-on Task:

   • Create a Change Set in a sandbox:
     • Include an Apex class, a trigger, and a custom object.
   • Upload it to a target org.

3. Validate and Deploy:

   • Test the deployment in the target org.

4. Summarize:

   • Write notes on Change Set best practices:
     • Validate before deploying.
     • Include dependencies.

Day 4: Exploring Salesforce DX

Objective:

• Learn how Salesforce DX streamlines CI/CD workflows and metadata management.

Tasks:

1. Study Salesforce DX Basics:

   • Understand Scratch Orgs and their use in development.
   • Learn key CLI commands (sfdx force:source:push, sfdx force:source:pull).

2. Hands-on Task:

   • Create a Scratch Org using CLI:

     sfdx force:org:create -s -f config/project-scratch-def.json -a MyScratchOrg
     

   • Deploy metadata:

     sfdx force:source:deploy -p force-app/main/default
     

   • Retrieve metadata:

     sfdx force:source:retrieve -m ApexClass:MyClass
     

3. Test Deployment:

   • Verify that changes appear in the Scratch Org.

4. Summarize:

   • Note key commands and their purposes.

Day 5: Mock Exam Practice

Objective:

• Simulate the PDI exam and refine weak areas.

Tasks:

1. Take a Full-Length Mock Exam:

   • Use a PDI-specific practice test platform (e.g., Focus on Force).
   • Time yourself to replicate real exam conditions.

2. Review Results:

   • Identify weak areas (e.g., low scores in Process Automation or SOQL).

3. Revisit Weak Areas:

   • Revise relevant notes and redo practice exercises for improvement.

Day 6: Final Review

Objective:

• Consolidate knowledge from all four weeks.

Tasks:

1. Flashcard Review:

   • Go through flashcards for all knowledge areas:
     • Developer Fundamentals.
     • Process Automation and Logic.
     • User Interface.
     • Testing, Debugging, and Deployment.

2. Practice Coding:

   • Write a trigger, a test class, and an LWC component.

3. Revise Notes:

   • Summarize key concepts and best practices.

Day 7: Rest and Confidence Building

Objective:

• Prepare mentally for the exam day.

Tasks:

1. Light Review:

   • Skim through notes and flashcards.

2. Relax:

   • Avoid studying heavily; focus on confidence building.

3. Prepare for Exam:

   • Ensure readiness: ID, exam details, quiet space.

Conclusion

This plan ensures a comprehensive preparation for the PDI exam. It incorporates efficient learning techniques and hands-on practice to build both theoretical and practical Salesforce skills.