CRM lifecycle

Clear Explanation

What it is: CRM lifecycle means: Understand how a potential customer becomes a lead, then an account/contact, then an opportunity, and finally a customer who needs support and long-term relationship management.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain CRM lifecycle in simple words with one Salesforce example.
• When would you use CRM lifecycle, and when would you avoid it?
• What can go wrong if CRM lifecycle is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for CRM lifecycle.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Salesforce clouds

Clear Explanation

What it is: Salesforce clouds means: Learn where Sales Cloud, Service Cloud, Experience Cloud, Marketing-related capabilities, CPQ concepts, Field Service, and Platform apps fit in real implementations.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Salesforce clouds in simple words with one Salesforce example.
• When would you use Salesforce clouds, and when would you avoid it?
• What can go wrong if Salesforce clouds is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Salesforce clouds.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Org, app, object, record, field

Clear Explanation

What it is: Org, app, object, record, field is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Org, app, object, record, field in simple words with one Salesforce example.
• When would you use Org, app, object, record, field, and when would you avoid it?
• What can go wrong if Org, app, object, record, field is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Org, app, object, record, field.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Data vs metadata

Clear Explanation

What it is: Data vs metadata means: Separate business records from configuration. Data is customer information; metadata is the setup and code that defines how Salesforce behaves.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Data vs metadata in simple words with one Salesforce example.
• When would you use Data vs metadata, and when would you avoid it?
• What can go wrong if Data vs metadata is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Data vs metadata.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Production, sandbox, scratch org

Clear Explanation

What it is: Production, sandbox, scratch org means: Use separate environments for building, testing, training, integration testing, and production release.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Production, sandbox, scratch org in simple words with one Salesforce example.
• When would you use Production, sandbox, scratch org, and when would you avoid it?
• What can go wrong if Production, sandbox, scratch org is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Production, sandbox, scratch org.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Lightning Experience navigation

Clear Explanation

What it is: Lightning Experience navigation means: Understand navigation bar, app launcher, object home, record pages, related lists, global actions, utility bar, search, and console navigation.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Lightning Experience navigation in simple words with one Salesforce example.
• When would you use Lightning Experience navigation, and when would you avoid it?
• What can go wrong if Lightning Experience navigation is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Lightning Experience navigation.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Admin, developer, consultant, architect roles

Clear Explanation

What it is: Admin, developer, consultant, architect roles means: Understand how Salesforce project roles differ and where each role contributes during requirements, build, testing, deployment, and support.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Admin, developer, consultant, architect roles in simple words with one Salesforce example.
• When would you use Admin, developer, consultant, architect roles, and when would you avoid it?
• What can go wrong if Admin, developer, consultant, architect roles is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Admin, developer, consultant, architect roles.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Project lifecycle

Clear Explanation

What it is: Project lifecycle means: Follow a safe project lifecycle: requirement, design, build, review, test, deploy, train, support, and improve.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Project lifecycle in simple words with one Salesforce example.
• When would you use Project lifecycle, and when would you avoid it?
• What can go wrong if Project lifecycle is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Project lifecycle.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Certification roadmap

Clear Explanation

What it is: Certification roadmap means: Plan learning across Salesforce Administrator, Platform App Builder, Platform Developer I, Advanced Administrator, Platform Developer II, Consultant, and Architect paths.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Certification roadmap in simple words with one Salesforce example.
• When would you use Certification roadmap, and when would you avoid it?
• What can go wrong if Certification roadmap is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Certification roadmap.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Standard objects

Clear Explanation

What it is: Standard objects is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Standard objects in simple words with one Salesforce example.
• When would you use Standard objects, and when would you avoid it?
• What can go wrong if Standard objects is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Standard objects in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Custom objects

Clear Explanation

What it is: Custom objects is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Custom objects in simple words with one Salesforce example.
• When would you use Custom objects, and when would you avoid it?
• What can go wrong if Custom objects is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Custom objects in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Field types

Clear Explanation

What it is: Field types is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Field types in simple words with one Salesforce example.
• When would you use Field types, and when would you avoid it?
• What can go wrong if Field types is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Field types in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Lookup relationship

Clear Explanation

What it is: Lookup relationship is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Lookup relationship in simple words with one Salesforce example.
• When would you use Lookup relationship, and when would you avoid it?
• What can go wrong if Lookup relationship is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Lookup relationship in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Master-detail relationship

Clear Explanation

What it is: Master-detail relationship is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Master-detail relationship in simple words with one Salesforce example.
• When would you use Master-detail relationship, and when would you avoid it?
• What can go wrong if Master-detail relationship is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Master-detail relationship in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Junction object

Clear Explanation

What it is: Junction object is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Junction object in simple words with one Salesforce example.
• When would you use Junction object, and when would you avoid it?
• What can go wrong if Junction object is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Junction object in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Schema Builder

Clear Explanation

What it is: Schema Builder is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Schema Builder in simple words with one Salesforce example.
• When would you use Schema Builder, and when would you avoid it?
• What can go wrong if Schema Builder is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Schema Builder in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Record types

Clear Explanation

What it is: Record types is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Record types in simple words with one Salesforce example.
• When would you use Record types, and when would you avoid it?
• What can go wrong if Record types is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Record types in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Business processes

Clear Explanation

What it is: Business processes is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Business processes in simple words with one Salesforce example.
• When would you use Business processes, and when would you avoid it?
• What can go wrong if Business processes is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Business processes in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Page layouts

Clear Explanation

What it is: Page layouts is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Page layouts in simple words with one Salesforce example.
• When would you use Page layouts, and when would you avoid it?
• What can go wrong if Page layouts is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Page layouts.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Compact layouts

Clear Explanation

What it is: Compact layouts is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Compact layouts in simple words with one Salesforce example.
• When would you use Compact layouts, and when would you avoid it?
• What can go wrong if Compact layouts is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Compact layouts.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Lightning record pages

Clear Explanation

What it is: Lightning record pages is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Lightning record pages in simple words with one Salesforce example.
• When would you use Lightning record pages, and when would you avoid it?
• What can go wrong if Lightning record pages is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Lightning record pages.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Dynamic forms

Clear Explanation

What it is: Dynamic forms is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Dynamic forms in simple words with one Salesforce example.
• When would you use Dynamic forms, and when would you avoid it?
• What can go wrong if Dynamic forms is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Dynamic forms.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Validation rules

Clear Explanation

What it is: Validation rules is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Validation rules in simple words with one Salesforce example.
• When would you use Validation rules, and when would you avoid it?
• What can go wrong if Validation rules is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Validation rules in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Formula fields

Clear Explanation

What it is: Formula fields is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Formula fields in simple words with one Salesforce example.
• When would you use Formula fields, and when would you avoid it?
• What can go wrong if Formula fields is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Formula fields in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Roll-up summary fields

Clear Explanation

What it is: Roll-up summary fields is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Roll-up summary fields in simple words with one Salesforce example.
• When would you use Roll-up summary fields, and when would you avoid it?
• What can go wrong if Roll-up summary fields is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Roll-up summary fields in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Naming standards

Clear Explanation

What it is: Naming standards helps Salesforce teams release changes safely.

Why it matters: Salesforce orgs contain many connected metadata types. A small field, Flow, Apex, or permission change can affect users, reports, integrations, and tests.

How to Understand / Build It

1. Track metadata in source control.
2. Validate changes in QA/UAT before production.
3. Run tests and static checks.
4. Create release notes and rollback steps.
5. Smoke test immediately after deployment.

Example

Release checklist:
1. Requirement approved
2. Metadata committed to Git
3. Apex tests passed
4. Flow and UI tested with business user
5. Deployment validated
6. Release notes prepared
7. Rollback steps prepared
8. Post-deploy smoke test completed

Real Project Checklist

• No undocumented production changes.
• Use pull requests or peer review.
• Validate before release window.
• Keep test evidence.
• Communicate user impact.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Naming standards in simple words with one Salesforce example.
• When would you use Naming standards, and when would you avoid it?
• What can go wrong if Naming standards is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Naming standards.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Security model overview

Clear Explanation

What it is: Security model overview is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Security model overview in simple words with one Salesforce example.
• When would you use Security model overview, and when would you avoid it?
• What can go wrong if Security model overview is designed badly?
• How do object permissions, field-level security, and sharing work together?
• How would you troubleshoot a user who cannot see a record?

Hands-on Practice

• Create a test user and apply Security model overview.
• Test access as System Administrator and as the test user.
• Capture a security matrix with object, field, and record access.
• Document the troubleshooting steps.

Portfolio Evidence

Users and licenses

Clear Explanation

What it is: Users and licenses means: Create users, assign licenses, reset passwords, freeze users, deactivate users, and understand license limitations.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Users and licenses in simple words with one Salesforce example.
• When would you use Users and licenses, and when would you avoid it?
• What can go wrong if Users and licenses is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Users and licenses.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Profiles

Clear Explanation

What it is: Profiles is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Profiles in simple words with one Salesforce example.
• When would you use Profiles, and when would you avoid it?
• What can go wrong if Profiles is designed badly?
• How do object permissions, field-level security, and sharing work together?
• How would you troubleshoot a user who cannot see a record?

Hands-on Practice

• Create a test user and apply Profiles.
• Test access as System Administrator and as the test user.
• Capture a security matrix with object, field, and record access.
• Document the troubleshooting steps.

Portfolio Evidence

Permission sets

Clear Explanation

What it is: Permission sets is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Permission sets in simple words with one Salesforce example.
• When would you use Permission sets, and when would you avoid it?
• What can go wrong if Permission sets is designed badly?
• How do object permissions, field-level security, and sharing work together?
• How would you troubleshoot a user who cannot see a record?

Hands-on Practice

• Create a test user and apply Permission sets.
• Test access as System Administrator and as the test user.
• Capture a security matrix with object, field, and record access.
• Document the troubleshooting steps.

Portfolio Evidence

Permission set groups

Clear Explanation

What it is: Permission set groups is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Permission set groups in simple words with one Salesforce example.
• When would you use Permission set groups, and when would you avoid it?
• What can go wrong if Permission set groups is designed badly?
• How do object permissions, field-level security, and sharing work together?
• How would you troubleshoot a user who cannot see a record?

Hands-on Practice

• Create a test user and apply Permission set groups.
• Test access as System Administrator and as the test user.
• Capture a security matrix with object, field, and record access.
• Document the troubleshooting steps.

Portfolio Evidence

Object permissions

Clear Explanation

What it is: Object permissions is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Object permissions in simple words with one Salesforce example.
• When would you use Object permissions, and when would you avoid it?
• What can go wrong if Object permissions is designed badly?
• How do object permissions, field-level security, and sharing work together?
• How would you troubleshoot a user who cannot see a record?

Hands-on Practice

• Create a test user and apply Object permissions.
• Test access as System Administrator and as the test user.
• Capture a security matrix with object, field, and record access.
• Document the troubleshooting steps.

Portfolio Evidence

Field-level security

Clear Explanation

What it is: Field-level security is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Field-level security in simple words with one Salesforce example.
• When would you use Field-level security, and when would you avoid it?
• What can go wrong if Field-level security is designed badly?
• How do object permissions, field-level security, and sharing work together?
• How would you troubleshoot a user who cannot see a record?

Hands-on Practice

• Create a test user and apply Field-level security.
• Test access as System Administrator and as the test user.
• Capture a security matrix with object, field, and record access.
• Document the troubleshooting steps.

Portfolio Evidence

Organization-wide defaults

Clear Explanation

What it is: Organization-wide defaults is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Organization-wide defaults in simple words with one Salesforce example.
• When would you use Organization-wide defaults, and when would you avoid it?
• What can go wrong if Organization-wide defaults is designed badly?
• How do object permissions, field-level security, and sharing work together?
• How would you troubleshoot a user who cannot see a record?

Hands-on Practice

• Create a test user and apply Organization-wide defaults.
• Test access as System Administrator and as the test user.
• Capture a security matrix with object, field, and record access.
• Document the troubleshooting steps.

Portfolio Evidence

Role hierarchy

Clear Explanation

What it is: Role hierarchy is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Role hierarchy in simple words with one Salesforce example.
• When would you use Role hierarchy, and when would you avoid it?
• What can go wrong if Role hierarchy is designed badly?
• How do object permissions, field-level security, and sharing work together?
• How would you troubleshoot a user who cannot see a record?

Hands-on Practice

• Create a test user and apply Role hierarchy.
• Test access as System Administrator and as the test user.
• Capture a security matrix with object, field, and record access.
• Document the troubleshooting steps.

Portfolio Evidence

Sharing rules

Clear Explanation

What it is: Sharing rules is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Sharing rules in simple words with one Salesforce example.
• When would you use Sharing rules, and when would you avoid it?
• What can go wrong if Sharing rules is designed badly?
• How do object permissions, field-level security, and sharing work together?
• How would you troubleshoot a user who cannot see a record?

Hands-on Practice

• Create a test user and apply Sharing rules.
• Test access as System Administrator and as the test user.
• Capture a security matrix with object, field, and record access.
• Document the troubleshooting steps.

Portfolio Evidence

Manual sharing

Clear Explanation

What it is: Manual sharing is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Manual sharing in simple words with one Salesforce example.
• When would you use Manual sharing, and when would you avoid it?
• What can go wrong if Manual sharing is designed badly?
• How do object permissions, field-level security, and sharing work together?
• How would you troubleshoot a user who cannot see a record?

Hands-on Practice

• Create a test user and apply Manual sharing.
• Test access as System Administrator and as the test user.
• Capture a security matrix with object, field, and record access.
• Document the troubleshooting steps.

Portfolio Evidence

Public groups

Clear Explanation

What it is: Public groups is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Public groups in simple words with one Salesforce example.
• When would you use Public groups, and when would you avoid it?
• What can go wrong if Public groups is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Public groups.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Queues

Clear Explanation

What it is: Queues means: Use queues for shared ownership of leads, cases, and custom records.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Queues in simple words with one Salesforce example.
• When would you use Queues, and when would you avoid it?
• What can go wrong if Queues is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Queues.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Teams

Clear Explanation

What it is: Teams means: Use account teams, opportunity teams, and case teams to support collaborative access.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Teams in simple words with one Salesforce example.
• When would you use Teams, and when would you avoid it?
• What can go wrong if Teams is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Teams.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Login security and MFA

Clear Explanation

What it is: Login security and MFA is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Login security and MFA in simple words with one Salesforce example.
• When would you use Login security and MFA, and when would you avoid it?
• What can go wrong if Login security and MFA is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Login security and MFA.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Setup Audit Trail

Clear Explanation

What it is: Setup Audit Trail is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Setup Audit Trail in simple words with one Salesforce example.
• When would you use Setup Audit Trail, and when would you avoid it?
• What can go wrong if Setup Audit Trail is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Setup Audit Trail.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Field History Tracking

Clear Explanation

What it is: Field History Tracking is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Field History Tracking in simple words with one Salesforce example.
• When would you use Field History Tracking, and when would you avoid it?
• What can go wrong if Field History Tracking is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Field History Tracking.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Security troubleshooting

Clear Explanation

What it is: Security troubleshooting is part of Salesforce access control. It decides who can log in, which apps and objects they can use, which fields they can see, and which records they can access.

Why it matters: Security is layered in Salesforce. A user may have object permission but still not see a record because record sharing blocks it, or may see a page layout field but not access it because field-level security blocks it.

How to Understand / Build It

1. Check login and license first.
2. Check profile and permission sets for app, tab, object, and field permissions.
3. Check organization-wide defaults to understand the baseline record visibility.
4. Use role hierarchy, sharing rules, teams, queues, or manual sharing to open record access.
5. Test using a real non-admin user, not only with System Administrator.

Example

Access troubleshooting example:
Problem: A sales user cannot edit Account.Rating.
Check:
1. User is active and has correct license.
2. Profile/permission set gives Account Read and Edit.
3. Field-Level Security makes Rating visible and editable.
4. Page layout or dynamic form shows the field.
5. Record access gives Edit access to that Account.
6. Validation rule is not blocking the save.

Real Project Checklist

• Prefer least privilege.
• Use permission sets for extra access instead of cloning many profiles.
• Do not use View All Data or Modify All Data as a shortcut.
• Remember page layout visibility is not security.
• Keep evidence for access changes and approvals.

Common Mistakes

• Confusing object permission with record access.
• Assuming page layout visibility is security.
• Giving broad admin permissions to solve a small access issue.
• Not testing with the affected user's profile and permission sets.
• Changing OWD without impact analysis.

Interview Questions

• Explain Security troubleshooting in simple words with one Salesforce example.
• When would you use Security troubleshooting, and when would you avoid it?
• What can go wrong if Security troubleshooting is designed badly?
• How do object permissions, field-level security, and sharing work together?
• How would you troubleshoot a user who cannot see a record?

Hands-on Practice

• Create a test user and apply Security troubleshooting.
• Test access as System Administrator and as the test user.
• Capture a security matrix with object, field, and record access.
• Document the troubleshooting steps.

Portfolio Evidence

Automation tools overview

Clear Explanation

What it is: Automation tools overview automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Automation tools overview in simple words with one Salesforce example.
• When would you use Automation tools overview, and when would you avoid it?
• What can go wrong if Automation tools overview is designed badly?
• When should you use before-save flow instead of after-save flow?
• How do you prevent recursion or unexpected automation behavior?

Hands-on Practice

• Build a small automation using Automation tools overview.
• Run Flow Debug with a passing case and a failing case.
• Add a fault path or error handling plan.
• Test single record and bulk update behavior.

Portfolio Evidence

Flow Builder basics

Clear Explanation

What it is: Flow Builder basics automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Flow Builder basics in simple words with one Salesforce example.
• When would you use Flow Builder basics, and when would you avoid it?
• What can go wrong if Flow Builder basics is designed badly?
• When should you use before-save flow instead of after-save flow?
• How do you prevent recursion or unexpected automation behavior?

Hands-on Practice

• Build a small automation using Flow Builder basics.
• Run Flow Debug with a passing case and a failing case.
• Add a fault path or error handling plan.
• Test single record and bulk update behavior.

Portfolio Evidence

Screen flows

Clear Explanation

What it is: Screen flows automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Screen flows in simple words with one Salesforce example.
• When would you use Screen flows, and when would you avoid it?
• What can go wrong if Screen flows is designed badly?
• When should you use before-save flow instead of after-save flow?
• How do you prevent recursion or unexpected automation behavior?

Hands-on Practice

• Build a small automation using Screen flows.
• Run Flow Debug with a passing case and a failing case.
• Add a fault path or error handling plan.
• Test single record and bulk update behavior.

Portfolio Evidence

Record-triggered flows

Clear Explanation

What it is: Record-triggered flows automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Record-triggered flows in simple words with one Salesforce example.
• When would you use Record-triggered flows, and when would you avoid it?
• What can go wrong if Record-triggered flows is designed badly?
• When should you use before-save flow instead of after-save flow?
• How do you prevent recursion or unexpected automation behavior?

Hands-on Practice

• Build a small automation using Record-triggered flows.
• Run Flow Debug with a passing case and a failing case.
• Add a fault path or error handling plan.
• Test single record and bulk update behavior.

Portfolio Evidence

Before-save flows

Clear Explanation

What it is: Before-save flows automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Before-save flows in simple words with one Salesforce example.
• When would you use Before-save flows, and when would you avoid it?
• What can go wrong if Before-save flows is designed badly?
• When should you use before-save flow instead of after-save flow?
• How do you prevent recursion or unexpected automation behavior?

Hands-on Practice

• Build a small automation using Before-save flows.
• Run Flow Debug with a passing case and a failing case.
• Add a fault path or error handling plan.
• Test single record and bulk update behavior.

Portfolio Evidence

After-save flows

Clear Explanation

What it is: After-save flows automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain After-save flows in simple words with one Salesforce example.
• When would you use After-save flows, and when would you avoid it?
• What can go wrong if After-save flows is designed badly?
• When should you use before-save flow instead of after-save flow?
• How do you prevent recursion or unexpected automation behavior?

Hands-on Practice

• Build a small automation using After-save flows.
• Run Flow Debug with a passing case and a failing case.
• Add a fault path or error handling plan.
• Test single record and bulk update behavior.

Portfolio Evidence

Scheduled flows

Clear Explanation

What it is: Scheduled flows automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Scheduled flows in simple words with one Salesforce example.
• When would you use Scheduled flows, and when would you avoid it?
• What can go wrong if Scheduled flows is designed badly?
• When should you use before-save flow instead of after-save flow?
• How do you prevent recursion or unexpected automation behavior?

Hands-on Practice

• Build a small automation using Scheduled flows.
• Run Flow Debug with a passing case and a failing case.
• Add a fault path or error handling plan.
• Test single record and bulk update behavior.

Portfolio Evidence

Autolaunched flows and subflows

Clear Explanation

What it is: Autolaunched flows and subflows automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Autolaunched flows and subflows in simple words with one Salesforce example.
• When would you use Autolaunched flows and subflows, and when would you avoid it?
• What can go wrong if Autolaunched flows and subflows is designed badly?
• When should you use before-save flow instead of after-save flow?
• How do you prevent recursion or unexpected automation behavior?

Hands-on Practice

• Build a small automation using Autolaunched flows and subflows.
• Run Flow Debug with a passing case and a failing case.
• Add a fault path or error handling plan.
• Test single record and bulk update behavior.

Portfolio Evidence

Flow variables and resources

Clear Explanation

What it is: Flow variables and resources automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Flow variables and resources in simple words with one Salesforce example.
• When would you use Flow variables and resources, and when would you avoid it?
• What can go wrong if Flow variables and resources is designed badly?
• When should you use before-save flow instead of after-save flow?
• How do you prevent recursion or unexpected automation behavior?

Hands-on Practice

• Build a small automation using Flow variables and resources.
• Run Flow Debug with a passing case and a failing case.
• Add a fault path or error handling plan.
• Test single record and bulk update behavior.

Portfolio Evidence

Flow collections and loops

Clear Explanation

What it is: Flow collections and loops automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Flow collections and loops in simple words with one Salesforce example.
• When would you use Flow collections and loops, and when would you avoid it?
• What can go wrong if Flow collections and loops is designed badly?
• When should you use before-save flow instead of after-save flow?
• How do you prevent recursion or unexpected automation behavior?

Hands-on Practice

• Build a small automation using Flow collections and loops.
• Run Flow Debug with a passing case and a failing case.
• Add a fault path or error handling plan.
• Test single record and bulk update behavior.

Portfolio Evidence

Flow decisions

Clear Explanation

What it is: Flow decisions automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Flow decisions in simple words with one Salesforce example.
• When would you use Flow decisions, and when would you avoid it?
• What can go wrong if Flow decisions is designed badly?
• When should you use before-save flow instead of after-save flow?
• How do you prevent recursion or unexpected automation behavior?

Hands-on Practice

• Build a small automation using Flow decisions.
• Run Flow Debug with a passing case and a failing case.
• Add a fault path or error handling plan.
• Test single record and bulk update behavior.

Portfolio Evidence

Flow fault paths

Clear Explanation

What it is: Flow fault paths automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Flow fault paths in simple words with one Salesforce example.
• When would you use Flow fault paths, and when would you avoid it?
• What can go wrong if Flow fault paths is designed badly?
• When should you use before-save flow instead of after-save flow?
• How do you prevent recursion or unexpected automation behavior?

Hands-on Practice

• Build a small automation using Flow fault paths.
• Run Flow Debug with a passing case and a failing case.
• Add a fault path or error handling plan.
• Test single record and bulk update behavior.

Portfolio Evidence

Approval processes

Clear Explanation

What it is: Approval processes automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Approval processes in simple words with one Salesforce example.
• When would you use Approval processes, and when would you avoid it?
• What can go wrong if Approval processes is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Approval processes.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Email templates and alerts

Clear Explanation

What it is: Email templates and alerts automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Email templates and alerts in simple words with one Salesforce example.
• When would you use Email templates and alerts, and when would you avoid it?
• What can go wrong if Email templates and alerts is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Email templates and alerts.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Assignment rules

Clear Explanation

What it is: Assignment rules automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Assignment rules in simple words with one Salesforce example.
• When would you use Assignment rules, and when would you avoid it?
• What can go wrong if Assignment rules is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Assignment rules.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Escalation rules

Clear Explanation

What it is: Escalation rules automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Creating multiple flows on the same object with overlapping responsibility.
• Forgetting fault paths and making errors hard to support.
• Hard-coding IDs from one org.
• Testing only one UI save and not bulk updates.
• Using automation when a formula or validation rule would be simpler.

Interview Questions

• Explain Escalation rules in simple words with one Salesforce example.
• When would you use Escalation rules, and when would you avoid it?
• What can go wrong if Escalation rules is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Escalation rules.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Path and Guidance for Success

Clear Explanation

What it is: Path and Guidance for Success automates or guides business work in Salesforce. It can update fields, create records, route work, collect user input, send notifications, or enforce process steps.

Why it matters: Good automation saves time and improves data quality. Bad automation creates recursion, confusing errors, slow saves, duplicate updates, and production incidents.

How to Understand / Build It

1. Write the trigger condition clearly: when should this run?
2. Choose the correct tool: screen flow for guided UI, before-save flow for same-record updates, after-save flow for related records/actions, scheduled flow for time-based work.
3. Use entry criteria so the automation does not run when nothing relevant changed.
4. Add fault paths or error logging so support teams can troubleshoot.
5. Test one record, many records, error cases, and user permission cases.

Example

Record-triggered flow example:
Object: Opportunity
Trigger: Created or Updated
Entry criteria:
- Stage = Negotiation/Review
- Amount > 100000
Action:
- Create Task for Opportunity Owner
Task:
- Subject = Follow up with account owner
- Due Date = Today
- Related To = Opportunity Account

Real Project Checklist

• Use before-save flow for simple same-record field updates.
• Use after-save flow when related records or actions are needed.
• Avoid hard-coded IDs; use labels, custom metadata, or queries.
• Add a fault path for record create/update elements.
• Document flow purpose, owner, and test scenarios.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Path and Guidance for Success in simple words with one Salesforce example.
• When would you use Path and Guidance for Success, and when would you avoid it?
• What can go wrong if Path and Guidance for Success is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Path and Guidance for Success.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Order of execution

Clear Explanation

What it is: Order of execution means: Understand the sequence of validation rules, flows, triggers, assignment rules, workflow-style actions, and database save behavior.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Order of execution in simple words with one Salesforce example.
• When would you use Order of execution, and when would you avoid it?
• What can go wrong if Order of execution is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Order of execution.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Automation architecture

Clear Explanation

What it is: Automation architecture is an expert-level Salesforce architecture topic.

Why it matters: Large Salesforce orgs fail when teams ignore performance, sharing recalculation, data volume, monitoring, resilience, and governance.

How to Understand / Build It

1. Identify scale: record count, user count, sharing complexity, API volume, and automation volume.
2. Design for selective queries, clean ownership, controlled sharing, and archival.
3. Review security, compliance, backup, monitoring, and support ownership.
4. Document trade-offs using architecture decision records.
5. Test with realistic volume before production release.

Example

Architecture review example:
Risk: Non-selective SOQL on Opportunity with millions of records
Mitigation:
- Add selective filters
- Use indexed fields where appropriate
- Archive old closed records
- Review query plan
- Test with realistic data volume
- Monitor slow transactions

Real Project Checklist

• Measure volume and sharing complexity.
• Review query selectivity.
• Avoid ownership and lookup skew.
• Document risks and decisions.
• Plan monitoring and recovery.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Automation architecture in simple words with one Salesforce example.
• When would you use Automation architecture, and when would you avoid it?
• What can go wrong if Automation architecture is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Automation architecture.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Data Import Wizard

Clear Explanation

What it is: Data Import Wizard controls how data enters, changes, backs up, and stays clean in Salesforce.

Why it matters: Data quality affects every report, automation, integration, AI feature, and user decision. Bad imports can damage thousands of records in seconds.

How to Understand / Build It

1. Export a backup before mass update or delete.
2. Clean the CSV and confirm required fields, picklist values, owners, and lookup keys.
3. Use external IDs for safer upsert operations.
4. Test with a small sample before running the full load.
5. Review success and error files, then validate counts and sample records.

Example

Data load plan:
Operation: Upsert Contacts
Match field: External_Contact_ID__c
Required fields:
- LastName
- Account External ID
- Email
Pre-check:
- Backup existing contacts
- Test 10 rows first
Post-check:
- Count inserted vs updated
- Review error CSV
- Validate sample records

Real Project Checklist

• Backup first.
• Use external IDs for matching.
• Load parents before children.
• Keep the CSV, mapping, success file, and error file.
• Run validation reports after import.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Data Import Wizard in simple words with one Salesforce example.
• When would you use Data Import Wizard, and when would you avoid it?
• What can go wrong if Data Import Wizard is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Data Import Wizard.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Data Loader

Clear Explanation

What it is: Data Loader controls how data enters, changes, backs up, and stays clean in Salesforce.

Why it matters: Data quality affects every report, automation, integration, AI feature, and user decision. Bad imports can damage thousands of records in seconds.

How to Understand / Build It

1. Export a backup before mass update or delete.
2. Clean the CSV and confirm required fields, picklist values, owners, and lookup keys.
3. Use external IDs for safer upsert operations.
4. Test with a small sample before running the full load.
5. Review success and error files, then validate counts and sample records.

Example

Data load plan:
Operation: Upsert Contacts
Match field: External_Contact_ID__c
Required fields:
- LastName
- Account External ID
- Email
Pre-check:
- Backup existing contacts
- Test 10 rows first
Post-check:
- Count inserted vs updated
- Review error CSV
- Validate sample records

Real Project Checklist

• Backup first.
• Use external IDs for matching.
• Load parents before children.
• Keep the CSV, mapping, success file, and error file.
• Run validation reports after import.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Data Loader in simple words with one Salesforce example.
• When would you use Data Loader, and when would you avoid it?
• What can go wrong if Data Loader is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Data Loader.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

External IDs and upsert

Clear Explanation

What it is: External IDs and upsert controls how data enters, changes, backs up, and stays clean in Salesforce.

Why it matters: Data quality affects every report, automation, integration, AI feature, and user decision. Bad imports can damage thousands of records in seconds.

How to Understand / Build It

1. Export a backup before mass update or delete.
2. Clean the CSV and confirm required fields, picklist values, owners, and lookup keys.
3. Use external IDs for safer upsert operations.
4. Test with a small sample before running the full load.
5. Review success and error files, then validate counts and sample records.

Example

Data load plan:
Operation: Upsert Contacts
Match field: External_Contact_ID__c
Required fields:
- LastName
- Account External ID
- Email
Pre-check:
- Backup existing contacts
- Test 10 rows first
Post-check:
- Count inserted vs updated
- Review error CSV
- Validate sample records

Real Project Checklist

• Backup first.
• Use external IDs for matching.
• Load parents before children.
• Keep the CSV, mapping, success file, and error file.
• Run validation reports after import.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain External IDs and upsert in simple words with one Salesforce example.
• When would you use External IDs and upsert, and when would you avoid it?
• What can go wrong if External IDs and upsert is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for External IDs and upsert.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Backup and restore planning

Clear Explanation

What it is: Backup and restore planning controls how data enters, changes, backs up, and stays clean in Salesforce.

Why it matters: Data quality affects every report, automation, integration, AI feature, and user decision. Bad imports can damage thousands of records in seconds.

How to Understand / Build It

1. Export a backup before mass update or delete.
2. Clean the CSV and confirm required fields, picklist values, owners, and lookup keys.
3. Use external IDs for safer upsert operations.
4. Test with a small sample before running the full load.
5. Review success and error files, then validate counts and sample records.

Example

Data load plan:
Operation: Upsert Contacts
Match field: External_Contact_ID__c
Required fields:
- LastName
- Account External ID
- Email
Pre-check:
- Backup existing contacts
- Test 10 rows first
Post-check:
- Count inserted vs updated
- Review error CSV
- Validate sample records

Real Project Checklist

• Backup first.
• Use external IDs for matching.
• Load parents before children.
• Keep the CSV, mapping, success file, and error file.
• Run validation reports after import.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Backup and restore planning in simple words with one Salesforce example.
• When would you use Backup and restore planning, and when would you avoid it?
• What can go wrong if Backup and restore planning is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Backup and restore planning.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Duplicate management

Clear Explanation

What it is: Duplicate management is part of the Salesforce data model and user experience. It defines how business information is stored, connected, validated, calculated, and shown to users.

Why it matters: A clean data model is the base of every good Salesforce org. If objects, fields, and relationships are wrong, reports become unreliable, automation becomes complex, and users lose trust.

How to Understand / Build It

1. Identify the real business entity, such as Customer, Project, Policy, Ticket, Order, or Invoice.
2. Decide whether a standard object already fits before creating a custom object.
3. Choose field types carefully because changing field type later can affect data, reports, formulas, integrations, and automation.
4. Design relationships based on ownership, security, reporting, and delete behavior.
5. Add validation rules only when the error message helps users fix the data.

Example

Example data model:
Object: Project__c
Fields:
- Project_Status__c: Picklist = Planned, Active, Blocked, Completed
- Start_Date__c: Date
- End_Date__c: Date
- Customer__c: Lookup(Account)
Validation:
- End Date must be greater than Start Date
Reporting:
- Projects by Status and Customer

Real Project Checklist

• Use standard objects first when they match the business process.
• Avoid duplicate fields with similar meanings.
• Use required fields carefully; do not block integrations or data migration unnecessarily.
• Define picklist values with business approval.
• Document API names, purpose, owner, and reporting use.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Duplicate management in simple words with one Salesforce example.
• When would you use Duplicate management, and when would you avoid it?
• What can go wrong if Duplicate management is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a small example for Duplicate management in a developer org.
• Create 5 sample records.
• Build one report to prove the design supports reporting.
• Write a short note explaining why this configuration was chosen.

Portfolio Evidence

Reports basics

Clear Explanation

What it is: Reports basics helps convert Salesforce data into business answers.

Why it matters: Reports and dashboards are only useful when the data model, filters, ownership, and definitions are correct. A beautiful dashboard with wrong filters is dangerous.

How to Understand / Build It

1. Start with the business question, not the chart type.
2. Select the correct report type and object relationship.
3. Apply filters that match the metric definition.
4. Group and summarize data so users can act on it.
5. Validate report numbers against sample records.

Example

Report example:
Question: Which high-value opportunities close this month?
Report type: Opportunities
Filters:
- Close Date = THIS MONTH
- Amount >= 100000
- Stage not equal Closed Lost
Group by:
- Owner
- Stage
Dashboard widgets:
- Pipeline by stage
- Top deals
- Monthly forecast

Real Project Checklist

• Write the metric definition.
• Check report type relationships.
• Validate filters with users.
• Remember sharing affects report visibility.
• Document dashboard owner and refresh expectations.

Common Mistakes

• Building a dashboard before agreeing on metric definitions.
• Using the wrong report type.
• Forgetting that sharing affects report results.
• Not validating report totals with sample records.
• No owner for dashboard maintenance.

Interview Questions

• Explain Reports basics in simple words with one Salesforce example.
• When would you use Reports basics, and when would you avoid it?
• What can go wrong if Reports basics is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Reports basics.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Report filters and formulas

Clear Explanation

What it is: Report filters and formulas helps convert Salesforce data into business answers.

Why it matters: Reports and dashboards are only useful when the data model, filters, ownership, and definitions are correct. A beautiful dashboard with wrong filters is dangerous.

How to Understand / Build It

1. Start with the business question, not the chart type.
2. Select the correct report type and object relationship.
3. Apply filters that match the metric definition.
4. Group and summarize data so users can act on it.
5. Validate report numbers against sample records.

Example

Report example:
Question: Which high-value opportunities close this month?
Report type: Opportunities
Filters:
- Close Date = THIS MONTH
- Amount >= 100000
- Stage not equal Closed Lost
Group by:
- Owner
- Stage
Dashboard widgets:
- Pipeline by stage
- Top deals
- Monthly forecast

Real Project Checklist

• Write the metric definition.
• Check report type relationships.
• Validate filters with users.
• Remember sharing affects report visibility.
• Document dashboard owner and refresh expectations.

Common Mistakes

• Building a dashboard before agreeing on metric definitions.
• Using the wrong report type.
• Forgetting that sharing affects report results.
• Not validating report totals with sample records.
• No owner for dashboard maintenance.

Interview Questions

• Explain Report filters and formulas in simple words with one Salesforce example.
• When would you use Report filters and formulas, and when would you avoid it?
• What can go wrong if Report filters and formulas is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Report filters and formulas.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Custom report types

Clear Explanation

What it is: Custom report types helps convert Salesforce data into business answers.

Why it matters: Reports and dashboards are only useful when the data model, filters, ownership, and definitions are correct. A beautiful dashboard with wrong filters is dangerous.

How to Understand / Build It

1. Start with the business question, not the chart type.
2. Select the correct report type and object relationship.
3. Apply filters that match the metric definition.
4. Group and summarize data so users can act on it.
5. Validate report numbers against sample records.

Example

Report example:
Question: Which high-value opportunities close this month?
Report type: Opportunities
Filters:
- Close Date = THIS MONTH
- Amount >= 100000
- Stage not equal Closed Lost
Group by:
- Owner
- Stage
Dashboard widgets:
- Pipeline by stage
- Top deals
- Monthly forecast

Real Project Checklist

• Write the metric definition.
• Check report type relationships.
• Validate filters with users.
• Remember sharing affects report visibility.
• Document dashboard owner and refresh expectations.

Common Mistakes

• Building a dashboard before agreeing on metric definitions.
• Using the wrong report type.
• Forgetting that sharing affects report results.
• Not validating report totals with sample records.
• No owner for dashboard maintenance.

Interview Questions

• Explain Custom report types in simple words with one Salesforce example.
• When would you use Custom report types, and when would you avoid it?
• What can go wrong if Custom report types is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Custom report types.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Dashboards

Clear Explanation

What it is: Dashboards helps convert Salesforce data into business answers.

Why it matters: Reports and dashboards are only useful when the data model, filters, ownership, and definitions are correct. A beautiful dashboard with wrong filters is dangerous.

How to Understand / Build It

1. Start with the business question, not the chart type.
2. Select the correct report type and object relationship.
3. Apply filters that match the metric definition.
4. Group and summarize data so users can act on it.
5. Validate report numbers against sample records.

Example

Report example:
Question: Which high-value opportunities close this month?
Report type: Opportunities
Filters:
- Close Date = THIS MONTH
- Amount >= 100000
- Stage not equal Closed Lost
Group by:
- Owner
- Stage
Dashboard widgets:
- Pipeline by stage
- Top deals
- Monthly forecast

Real Project Checklist

• Write the metric definition.
• Check report type relationships.
• Validate filters with users.
• Remember sharing affects report visibility.
• Document dashboard owner and refresh expectations.

Common Mistakes

• Building a dashboard before agreeing on metric definitions.
• Using the wrong report type.
• Forgetting that sharing affects report results.
• Not validating report totals with sample records.
• No owner for dashboard maintenance.

Interview Questions

• Explain Dashboards in simple words with one Salesforce example.
• When would you use Dashboards, and when would you avoid it?
• What can go wrong if Dashboards is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Dashboards.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Dynamic dashboards

Clear Explanation

What it is: Dynamic dashboards helps convert Salesforce data into business answers.

Why it matters: Reports and dashboards are only useful when the data model, filters, ownership, and definitions are correct. A beautiful dashboard with wrong filters is dangerous.

How to Understand / Build It

1. Start with the business question, not the chart type.
2. Select the correct report type and object relationship.
3. Apply filters that match the metric definition.
4. Group and summarize data so users can act on it.
5. Validate report numbers against sample records.

Example

Report example:
Question: Which high-value opportunities close this month?
Report type: Opportunities
Filters:
- Close Date = THIS MONTH
- Amount >= 100000
- Stage not equal Closed Lost
Group by:
- Owner
- Stage
Dashboard widgets:
- Pipeline by stage
- Top deals
- Monthly forecast

Real Project Checklist

• Write the metric definition.
• Check report type relationships.
• Validate filters with users.
• Remember sharing affects report visibility.
• Document dashboard owner and refresh expectations.

Common Mistakes

• Building a dashboard before agreeing on metric definitions.
• Using the wrong report type.
• Forgetting that sharing affects report results.
• Not validating report totals with sample records.
• No owner for dashboard maintenance.

Interview Questions

• Explain Dynamic dashboards in simple words with one Salesforce example.
• When would you use Dynamic dashboards, and when would you avoid it?
• What can go wrong if Dynamic dashboards is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Dynamic dashboards.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Sales Cloud overview

Clear Explanation

What it is: Sales Cloud overview means: Manage leads, accounts, contacts, opportunities, products, quotes, activities, and forecasts.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Sales Cloud overview in simple words with one Salesforce example.
• When would you use Sales Cloud overview, and when would you avoid it?
• What can go wrong if Sales Cloud overview is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Sales Cloud overview.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Lead management

Clear Explanation

What it is: Lead management means: Capture, qualify, assign, convert, and report on leads.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Lead management in simple words with one Salesforce example.
• When would you use Lead management, and when would you avoid it?
• What can go wrong if Lead management is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Lead management.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Opportunity management

Clear Explanation

What it is: Opportunity management means: Track deal stages, amount, probability, close date, next step, competitors, and products.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Opportunity management in simple words with one Salesforce example.
• When would you use Opportunity management, and when would you avoid it?
• What can go wrong if Opportunity management is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Opportunity management.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Products, price books, and quotes

Clear Explanation

What it is: Products, price books, and quotes means: Model products, prices, opportunity line items, and quote outputs.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Products, price books, and quotes in simple words with one Salesforce example.
• When would you use Products, price books, and quotes, and when would you avoid it?
• What can go wrong if Products, price books, and quotes is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Products, price books, and quotes.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Service Cloud overview

Clear Explanation

What it is: Service Cloud overview means: Manage customer support using cases, queues, assignments, escalation, knowledge, and console apps.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Service Cloud overview in simple words with one Salesforce example.
• When would you use Service Cloud overview, and when would you avoid it?
• What can go wrong if Service Cloud overview is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Service Cloud overview.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Case management

Clear Explanation

What it is: Case management means: Track customer issues from creation through assignment, work, escalation, and resolution.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Case management in simple words with one Salesforce example.
• When would you use Case management, and when would you avoid it?
• What can go wrong if Case management is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Case management.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Knowledge articles

Clear Explanation

What it is: Knowledge articles means: Create searchable support articles with publish lifecycle and visibility controls.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Knowledge articles in simple words with one Salesforce example.
• When would you use Knowledge articles, and when would you avoid it?
• What can go wrong if Knowledge articles is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Knowledge articles.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Experience Cloud basics

Clear Explanation

What it is: Experience Cloud basics means: Create customer or partner sites with external users, pages, branding, authentication, and sharing.

Why it matters: It matters because Salesforce projects fail when teams configure features without understanding users, data, access, automation, testing, and reporting impact.

How to Understand / Build It

1. Start from the business requirement and write the expected outcome in one sentence.
2. Identify affected users, objects, fields, records, automations, integrations, and reports.
3. Build in a sandbox or developer org, test with realistic data, then deploy through a controlled release.

Example

Requirement: create a maintainable Salesforce solution. Build the simplest secure configuration first, add Apex/LWC/integration only when declarative tools are not enough.

Real Project Checklist

• Requirement is written clearly.
• Security impact is checked.
• Automation and integration impact is checked.
• Test evidence is captured.
• Deployment and rollback notes are ready.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Experience Cloud basics in simple words with one Salesforce example.
• When would you use Experience Cloud basics, and when would you avoid it?
• What can go wrong if Experience Cloud basics is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Experience Cloud basics.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Developer setup

Clear Explanation

What it is: Developer setup supports professional Salesforce development and controlled metadata movement.

Why it matters: Without source control and repeatable deployment, teams overwrite each other's changes, lose history, and struggle to reproduce releases.

How to Understand / Build It

1. Create or retrieve metadata into a Salesforce DX project.
2. Use Git branches for work and pull requests for review.
3. Validate deployments in a test org before release.
4. Run Apex tests and review deployment errors.
5. Keep release notes and rollback steps.

Example

# Common Salesforce CLI workflow
sf org login web --alias dev
sf project retrieve start --metadata ApexClass --target-org dev
sf project deploy validate --source-dir force-app --target-org qa --test-level RunLocalTests
sf project deploy start --source-dir force-app --target-org qa --test-level RunLocalTests

Real Project Checklist

• Use Git for source history.
• Avoid editing directly in production.
• Validate before deploying.
• Run the correct Apex test level.
• Document release and rollback.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Developer setup in simple words with one Salesforce example.
• When would you use Developer setup, and when would you avoid it?
• What can go wrong if Developer setup is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Developer setup.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Salesforce DX project structure

Clear Explanation

What it is: Salesforce DX project structure supports professional Salesforce development and controlled metadata movement.

Why it matters: Without source control and repeatable deployment, teams overwrite each other's changes, lose history, and struggle to reproduce releases.

How to Understand / Build It

1. Create or retrieve metadata into a Salesforce DX project.
2. Use Git branches for work and pull requests for review.
3. Validate deployments in a test org before release.
4. Run Apex tests and review deployment errors.
5. Keep release notes and rollback steps.

Example

# Common Salesforce CLI workflow
sf org login web --alias dev
sf project retrieve start --metadata ApexClass --target-org dev
sf project deploy validate --source-dir force-app --target-org qa --test-level RunLocalTests
sf project deploy start --source-dir force-app --target-org qa --test-level RunLocalTests

Real Project Checklist

• Use Git for source history.
• Avoid editing directly in production.
• Validate before deploying.
• Run the correct Apex test level.
• Document release and rollback.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Salesforce DX project structure in simple words with one Salesforce example.
• When would you use Salesforce DX project structure, and when would you avoid it?
• What can go wrong if Salesforce DX project structure is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Salesforce DX project structure.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Metadata API basics

Clear Explanation

What it is: Metadata API basics supports professional Salesforce development and controlled metadata movement.

Why it matters: Without source control and repeatable deployment, teams overwrite each other's changes, lose history, and struggle to reproduce releases.

How to Understand / Build It

1. Create or retrieve metadata into a Salesforce DX project.
2. Use Git branches for work and pull requests for review.
3. Validate deployments in a test org before release.
4. Run Apex tests and review deployment errors.
5. Keep release notes and rollback steps.

Example

# Common Salesforce CLI workflow
sf org login web --alias dev
sf project retrieve start --metadata ApexClass --target-org dev
sf project deploy validate --source-dir force-app --target-org qa --test-level RunLocalTests
sf project deploy start --source-dir force-app --target-org qa --test-level RunLocalTests

Real Project Checklist

• Use Git for source history.
• Avoid editing directly in production.
• Validate before deploying.
• Run the correct Apex test level.
• Document release and rollback.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain Metadata API basics in simple words with one Salesforce example.
• When would you use Metadata API basics, and when would you avoid it?
• What can go wrong if Metadata API basics is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for Metadata API basics.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

Apex overview

Clear Explanation

What it is: Apex overview is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.

Common Mistakes

• SOQL inside loops.
• DML inside loops.
• Writing tests only to reach coverage, not to verify behavior.
• Ignoring CRUD/FLS for user-facing Apex.
• No debug logging or error context for support.

Interview Questions

• Explain Apex overview in simple words with one Salesforce example.
• When would you use Apex overview, and when would you avoid it?
• What can go wrong if Apex overview is designed badly?
• What does bulkification mean in Apex?
• How do governor limits influence your code design?

Hands-on Practice

• Write an Apex example for Apex overview.
• Create a test class with meaningful assertions.
• Test with 1 record and 200 records.
• Review debug logs and note SOQL/DML counts.

Portfolio Evidence

Apex classes

Clear Explanation

What it is: Apex classes is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.

Common Mistakes

• SOQL inside loops.
• DML inside loops.
• Writing tests only to reach coverage, not to verify behavior.
• Ignoring CRUD/FLS for user-facing Apex.
• No debug logging or error context for support.

Interview Questions

• Explain Apex classes in simple words with one Salesforce example.
• When would you use Apex classes, and when would you avoid it?
• What can go wrong if Apex classes is designed badly?
• What does bulkification mean in Apex?
• How do governor limits influence your code design?

Hands-on Practice

• Write an Apex example for Apex classes.
• Create a test class with meaningful assertions.
• Test with 1 record and 200 records.
• Review debug logs and note SOQL/DML counts.

Portfolio Evidence

Apex data types

Clear Explanation

What it is: Apex data types is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.

Common Mistakes

• SOQL inside loops.
• DML inside loops.
• Writing tests only to reach coverage, not to verify behavior.
• Ignoring CRUD/FLS for user-facing Apex.
• No debug logging or error context for support.

Interview Questions

• Explain Apex data types in simple words with one Salesforce example.
• When would you use Apex data types, and when would you avoid it?
• What can go wrong if Apex data types is designed badly?
• What does bulkification mean in Apex?
• How do governor limits influence your code design?

Hands-on Practice

• Write an Apex example for Apex data types.
• Create a test class with meaningful assertions.
• Test with 1 record and 200 records.
• Review debug logs and note SOQL/DML counts.

Portfolio Evidence

Apex collections

Clear Explanation

What it is: Apex collections is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.

Common Mistakes

• SOQL inside loops.
• DML inside loops.
• Writing tests only to reach coverage, not to verify behavior.
• Ignoring CRUD/FLS for user-facing Apex.
• No debug logging or error context for support.

Interview Questions

• Explain Apex collections in simple words with one Salesforce example.
• When would you use Apex collections, and when would you avoid it?
• What can go wrong if Apex collections is designed badly?
• What does bulkification mean in Apex?
• How do governor limits influence your code design?

Hands-on Practice

• Write an Apex example for Apex collections.
• Create a test class with meaningful assertions.
• Test with 1 record and 200 records.
• Review debug logs and note SOQL/DML counts.

Portfolio Evidence

SOQL basics

Clear Explanation

What it is: SOQL basics is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.

Common Mistakes

• SOQL inside loops.
• DML inside loops.
• Writing tests only to reach coverage, not to verify behavior.
• Ignoring CRUD/FLS for user-facing Apex.
• No debug logging or error context for support.

Interview Questions

• Explain SOQL basics in simple words with one Salesforce example.
• When would you use SOQL basics, and when would you avoid it?
• What can go wrong if SOQL basics is designed badly?
• What does bulkification mean in Apex?
• How do governor limits influence your code design?

Hands-on Practice

• Write an Apex example for SOQL basics.
• Create a test class with meaningful assertions.
• Test with 1 record and 200 records.
• Review debug logs and note SOQL/DML counts.

Portfolio Evidence

Relationship SOQL

Clear Explanation

What it is: Relationship SOQL is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.

Common Mistakes

• SOQL inside loops.
• DML inside loops.
• Writing tests only to reach coverage, not to verify behavior.
• Ignoring CRUD/FLS for user-facing Apex.
• No debug logging or error context for support.

Interview Questions

• Explain Relationship SOQL in simple words with one Salesforce example.
• When would you use Relationship SOQL, and when would you avoid it?
• What can go wrong if Relationship SOQL is designed badly?
• What does bulkification mean in Apex?
• How do governor limits influence your code design?

Hands-on Practice

• Write an Apex example for Relationship SOQL.
• Create a test class with meaningful assertions.
• Test with 1 record and 200 records.
• Review debug logs and note SOQL/DML counts.

Portfolio Evidence

Aggregate SOQL

Clear Explanation

What it is: Aggregate SOQL is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.

Common Mistakes

• SOQL inside loops.
• DML inside loops.
• Writing tests only to reach coverage, not to verify behavior.
• Ignoring CRUD/FLS for user-facing Apex.
• No debug logging or error context for support.

Interview Questions

• Explain Aggregate SOQL in simple words with one Salesforce example.
• When would you use Aggregate SOQL, and when would you avoid it?
• What can go wrong if Aggregate SOQL is designed badly?
• What does bulkification mean in Apex?
• How do governor limits influence your code design?

Hands-on Practice

• Write an Apex example for Aggregate SOQL.
• Create a test class with meaningful assertions.
• Test with 1 record and 200 records.
• Review debug logs and note SOQL/DML counts.

Portfolio Evidence

SOSL

Clear Explanation

What it is: SOSL is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.

Common Mistakes

• Building without a written requirement.
• Skipping sandbox testing.
• Ignoring security impact.
• Not checking automation or integration impact.
• Deploying without documentation and rollback notes.

Interview Questions

• Explain SOSL in simple words with one Salesforce example.
• When would you use SOSL, and when would you avoid it?
• What can go wrong if SOSL is designed badly?
• How would you test this before production?
• What documentation would you provide?

Hands-on Practice

• Create a mini demo or written design for SOSL.
• Add screenshots or command output.
• Write test evidence.
• Prepare a 2-minute explanation for interview/demo.

Portfolio Evidence

DML operations

Clear Explanation

What it is: DML operations is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.

Common Mistakes

• SOQL inside loops.
• DML inside loops.
• Writing tests only to reach coverage, not to verify behavior.
• Ignoring CRUD/FLS for user-facing Apex.
• No debug logging or error context for support.

Interview Questions

• Explain DML operations in simple words with one Salesforce example.
• When would you use DML operations, and when would you avoid it?
• What can go wrong if DML operations is designed badly?
• What does bulkification mean in Apex?
• How do governor limits influence your code design?

Hands-on Practice

• Write an Apex example for DML operations.
• Create a test class with meaningful assertions.
• Test with 1 record and 200 records.
• Review debug logs and note SOQL/DML counts.

Portfolio Evidence

Database methods

Clear Explanation

What it is: Database methods is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.

Common Mistakes

• SOQL inside loops.
• DML inside loops.
• Writing tests only to reach coverage, not to verify behavior.
• Ignoring CRUD/FLS for user-facing Apex.
• No debug logging or error context for support.

Interview Questions

• Explain Database methods in simple words with one Salesforce example.
• When would you use Database methods, and when would you avoid it?
• What can go wrong if Database methods is designed badly?
• What does bulkification mean in Apex?
• How do governor limits influence your code design?

Hands-on Practice

• Write an Apex example for Database methods.
• Create a test class with meaningful assertions.
• Test with 1 record and 200 records.
• Review debug logs and note SOQL/DML counts.

Portfolio Evidence

Transactions and savepoints

Clear Explanation

What it is: Transactions and savepoints is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.

Common Mistakes

• SOQL inside loops.
• DML inside loops.
• Writing tests only to reach coverage, not to verify behavior.
• Ignoring CRUD/FLS for user-facing Apex.
• No debug logging or error context for support.

Interview Questions

• Explain Transactions and savepoints in simple words with one Salesforce example.
• When would you use Transactions and savepoints, and when would you avoid it?
• What can go wrong if Transactions and savepoints is designed badly?
• What does bulkification mean in Apex?
• How do governor limits influence your code design?

Hands-on Practice

• Write an Apex example for Transactions and savepoints.
• Create a test class with meaningful assertions.
• Test with 1 record and 200 records.
• Review debug logs and note SOQL/DML counts.

Portfolio Evidence

Governor limits

Clear Explanation

What it is: Governor limits is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.

Common Mistakes

• SOQL inside loops.
• DML inside loops.
• Writing tests only to reach coverage, not to verify behavior.
• Ignoring CRUD/FLS for user-facing Apex.
• No debug logging or error context for support.

Interview Questions

• Explain Governor limits in simple words with one Salesforce example.
• When would you use Governor limits, and when would you avoid it?
• What can go wrong if Governor limits is designed badly?
• What does bulkification mean in Apex?
• How do governor limits influence your code design?

Hands-on Practice

• Write an Apex example for Governor limits.
• Create a test class with meaningful assertions.
• Test with 1 record and 200 records.
• Review debug logs and note SOQL/DML counts.

Portfolio Evidence

Bulkification

Clear Explanation

What it is: Bulkification is part of Salesforce backend development. It is used when declarative configuration cannot meet the requirement cleanly, safely, or efficiently.

Why it matters: Apex runs on a multitenant platform, so code must respect governor limits. Code that works for one record can fail for imports, integrations, and batch updates if it is not bulk-safe.

How to Understand / Build It

1. Use collections: Set<Id>, List<SObject>, and Map<Id, SObject>.
2. Query related records once outside loops.
3. Perform DML outside loops.
4. Separate trigger logic into handler/service/selector classes.
5. Write tests for success, failure, bulk records, and security behavior.

Example

// Bulk-safe Apex pattern
Set<Id> accountIds = new Set<Id>();

for (Contact c : Trigger.new) {
    if (c.AccountId != null) {
        accountIds.add(c.AccountId);
    }
}

Map<Id, Account> accountsById = new Map<Id, Account>([
    SELECT Id, Name, Industry
    FROM Account
    WHERE Id IN :accountIds
]);

// Process in memory, then perform DML once if needed.

Real Project Checklist

• No SOQL inside loops.
• No DML inside loops.
• Use handler/service classes.
• Assert expected behavior in tests.
• Review debug logs for CPU, SOQL, DML, and exceptions.