Salesforce Training with AgentForce

Key Topics:

Platform Architecture & Multi-Cloud Ecosystem

Agentforce: AI Agents, Einstein, Data Cloud

Admin Career Path in the AI Era

Developer Org Setup & Navigation

Key Topics :

Org Settings: Business Hours, Fiscal Year, Currencies, Localization

User Management: Profiles, Permission Sets, Delegated Admin

Security: MFA, SSO, OWD, Role Hierarchy, Sharing Rules

Object, Field, and Record-Level Security

Key Topics :

Objects: Standard, Custom, Schema Builder

Fields: Types, Formulas, Roll-Up Summaries, Dependencies

Relationships: Master-Detail, Lookup, Junction Objects

Page Layouts, Record Types, Validation Rules

Key Topics :

Import: Data Import Wizard, Data Loader

Export: Weekly Export, Manual Backup

Data Quality: Duplicate Management, Validation, Cleansing

AI Readiness: Data Completeness & Consistency

Key Topics :

Page Types: App, Home, Record Pages

Dynamic Forms & Actions

Custom App Development & Navigation

Mobile Configuration & Deployment

Key Topics :

Flow Types: Record-Triggered, Scheduled, Screen Flows

Flow Elements: Assignment, Decision, Loop, CRUD Operations

Approval Processes

Legacy Tools: Migration from Workflow & Process Builder

Key Topics :

Report Types: Tabular, Summary, Matrix, Joined

Filters, Grouping, Bucket Fields, Formulas

Dashboard Components & Dynamic Dashboards

Analytics Best Practices

Key Topics :

Agentforce Architecture: Atlas Reasoning Engine, Trust Layer

Setup: Licensing, Einstein Copilot, Permissions

Agent Builder: Service & Sales Agents, Topics, Instructions

Agent Actions: Standard & Custom Actions with Flow

Prompt Builder: Templates, Variables, Grounding

Data Cloud Integration & Knowledge Base

Security: Trust Layer, Privacy, Compliance

Deployment: Channels (Web, Mobile, Slack), Sandbox to Production

Monitoring: Performance Dashboards, Analytics, KPIs

Key Topics :

Sandbox Types & Management

Change Sets & Deployment Connections

DevOps Center: Git-Based Development, Pipelines

Testing: UAT, Regression, Test Data

Release Management & Monitoring

Key Topics :

Chatter & Collaboration

Activity Management & Calendar

Email Integration: Outlook, Gmail

Files & Content Management

AppExchange & Managed Packages

Performance Optimization & Best Practices

Certification Preparation

Capstone Project: End-to-End Org with AI Agent

Key Topics :

Introduction to [Force.com](http://Force.com) Platform (SaaS, PaaS, IaaS)

Apex Programming Basics & Syntax

Data Types & Variables

Access Modifiers (Private, Public, Global)

Operators & Expressions

Conditional Statements & Control Flow

Loops (for, while, do-while)

Key Topics :

List Collections (Declaration, Initialization, Methods)

Set Collections (Unique values, Methods)

Map Collections (Key-Value pairs, Iteration)

Nested Collections

Collection Best Practices & Performance Optimization

Key Topics :

Insert Operations

Update Operations

Delete Operations

Undelete Operations

Upsert Operations

Merge Operations

DML Exception Handling

Database Class Methods

Partial Success with Database Methods

Governor Limits & Bulkification

Key Topics :

Salesforce Object Query Language (SOQL) Basics

SELECT Statements & Field Selection

WHERE Clauses & Filtering

ORDER BY, LIMIT, OFFSET

Aggregate Functions (COUNT, SUM, AVG, MIN, MAX)

GROUP BY & HAVING Clauses

Date Functions & Literals

Salesforce Object Search Language (SOSL)

SOQL vs SOSL: When to Use Each

Key Topics :

Parent-to-Child Queries (Standard Objects)

Child-to-Parent Queries (Standard Objects)

Parent-to-Child Queries (Custom Objects)

Child-to-Parent Queries (Custom Objects)

Multi-level Relationship Queries

Polymorphic Relationships

Query Optimization Techniques

Key Topics :

Trigger Fundamentals & Syntax

Before Triggers (Insert, Update, Delete)

After Triggers (Insert, Update, Delete, Undelete)

Trigger Context Variables ([Trigger.new](http://Trigger.new), Trigger.old, etc.)

Trigger Best Practices & Design Patterns

Trigger Handler Classes

Recursive Trigger Prevention

Order of Execution in Salesforce

Trigger Framework Implementation

Key Topics :

Apex Classes & Objects

Methods (Instance, Static)

Constructors (Default, Parameterized)

Method Overloading

Inheritance & Polymorphism

Abstract Classes & Virtual Methods

Interfaces & Implementation

Inner Classes & Wrapper Classes

Enums

Exception Handling (try-catch-finally)

Custom Exceptions

Key Topics :

Future Methods (@future)

Batch Apex (Database.Batchable)

Queueable Apex (System.Queueable)

Scheduled Apex (Schedulable Interface)

Platform Events

REST API Integration (HTTP Callouts)

SOAP API Integration

REST Web Services (@RestResource)

SOAP Web Services (WebService keyword)

Authentication & Security

Key Topics :

Apex Testing Fundamentals

Test Classes & Test Methods (@isTest)

Test Data Creation & Management

System.assert Methods

Test Coverage Requirements

Mock Callouts & Testing Integrations

Debugging with Debug Logs

Developer Console & VS Code

Deployment Best Practices

Change Sets & Metadata API

Salesforce DX & CI/CD

Key Topics :

What is Agentforce? AI Agents in Salesforce

Agent Builder & Agent Configuration

Agent Types (Service Agent, Sales Agent, Custom Agents)

Natural Language Processing in Salesforce **Apex for Agentforce:**

Building Custom Actions for Agents

Invocable Apex Methods (@InvocableMethod)

Flow Integration with Agents

Agent Prompt Templates & Grounding

Data Retrieval for Agent Context **Advanced Agentforce Development:**

Agent API Integration

Custom Agent Logic with Apex

Agent Security & Data Access

Agent Performance Optimization

Agent Testing & Validation **Einstein GPT & Generative AI:**

Einstein GPT Integration

Prompt Engineering Best Practices

AI Model Selection & Configuration

Generative AI Use Cases **Real-World Agentforce Projects:**

Building a Customer Service Agent

Creating Sales Assistant Agents

Custom Business Process Automation with Agents

Agent Analytics & Monitoring

Key Topics :

HTML document structure and syntax

Text elements, lists, links, images, and media

HTML tables and forms

Semantic HTML5 elements

Accessibility (A11y) basics and ARIA

HTML best practices for Salesforce

Key Topics :

CSS syntax, selectors, and properties

Box model, backgrounds, borders, and shadows

Display, positioning, Flexbox, and CSS Grid

Responsive design with media queries

Salesforce Lightning Design System (SLDS)

SLDS utility classes and components

CSS animations and transitions

Shadow DOM styling

Key Topics :

Variables: var, let, const

Data types, operators, and conditional logic

Functions: declarations, expressions, arrow functions

Arrays: methods, iteration, manipulation

Objects: properties, methods, destructuring

Array methods: forEach, map, filter, reduce

ES6+ features: template literals, spread operator, rest parameters

DOM manipulation and event handling

Error handling and debugging

JavaScript best practices

Key Topics :

Asynchronous JavaScript fundamentals

Promises: creation, chaining, error handling

Async/await patterns

Fetch API and HTTP requests

JavaScript classes and OOP

Prototypes and inheritance

Modules and imports/exports

Higher-order functions and closures

Working with JSON

LocalStorage and SessionStorage

JavaScript design patterns

Performance optimization

Key Topics :

Node.js and npm fundamentals

Code quality tools: ESLint and Prettier

Git version control fundamentals

GitHub workflow and collaboration

Chrome DevTools mastery

VS Code for JavaScript development

JavaScript testing introduction (Jest)

Module bundlers and build tools

Modern JavaScript workflow

Preparing for Salesforce DX development

Key Topics :

What are Lightning Web Components (LWC)

LWC vs Aura Components

Web standards used in LWC

Salesforce DX environment setup

Salesforce CLI and VS Code Salesforce Extensions

LWC component structure and files

HTML templates and JavaScript in LWC

CSS styling and Shadow DOM

Component configuration (js-meta.xml)

LWC decorators: @api, @track, @wire

Component lifecycle hooks

Event handling in LWC

Lightning base components

Key Topics :

Data binding fundamentals in LWC

Reactive properties and @api decorator

Getters and computed values

Conditional rendering (if:true, if:false, lwc:if, lwc:elseif, lwc:else)

List rendering (for:each, iterator)

Working with forms and inputs

Input validation patterns

Component events: creating and dispatching

Parent-child communication

Component slots and composition

Dynamic components (lwc:dynamic)

Component styling patterns

Lightning Design System integration

Key Topics :

Data access options in LWC

Lightning Data Service (LDS) fundamentals

Wire service and @wire decorator

getRecord, getRecords, getFieldValue

Creating, updating, and deleting records with LDS

Working with Apex in LWC

Creating Apex classes for LWC (@AuraEnabled)

Wire Apex methods

Imperative Apex calls

refreshApex for data refresh

Working with objects and fields (@salesforce/schema)

Error handling patterns

Loading states and UI feedback

Key Topics :

Component communication patterns

Lightning Message Service (LMS)

Creating and deploying message channels

Publishing and subscribing to messages

Platform Events in LWC

Navigation in LWC (NavigationMixin)

Navigate to records, objects, list views

CurrentPageReference and URL parameters

Third-party JavaScript libraries

Loading static resources (loadScript, loadStyle)

Chart.js and D3.js integration

Custom labels and custom metadata

Performance optimization techniques

Security in LWC: Lightning Web Security (LWS), Trusted Mode

CRUD and FLS enforcement

Key Topics :

LWC testing with Jest

Setting up @salesforce/sfdx-lwc-jest

Writing Jest tests for components

Testing component rendering, user interactions, and properties

Testing wire adapters and Apex calls

Test coverage requirements (75%) **Debugging & Deployment:**

Chrome DevTools for LWC

VS Code debugging

Salesforce DX deployment (scratch orgs, sandboxes, production)

DevOps Center (2026)

CI/CD for LWC (GitHub Actions, Jenkins) **Agentforce Integration:**

Introduction to Agentforce - Salesforce's AI platform

Building AI-powered LWC components

Calling Agentforce actions from LWC

Einstein Copilot integration

Prompt Builder with LWC

Displaying AI responses in components

AI error handling and UX best practices **Winter '26 Features:**

Lightning Out 2.0 - Embed LWC in external apps

Trusted Mode - Access browser APIs

LWC for Local Actions - Use LWC in Screen Flows **Production Readiness:**

Performance testing

Security review

Accessibility audit

Cross-browser and mobile testing

Key Topics :

Role of a Modern Business Analyst

Agile Mindset & Scrum vs. Waterfall

Scrum Framework Deep Dive (Roles, Events, Artifacts)

User Stories, Epics, Themes & Acceptance Criteria

Requirement Backlogs in Sheets & Azure Boards

Introduction to GenAI in BA Work

BA Tools & Skills for the Future

Application Lifecycle Management (ALM)

Key Topics :

Discovery Phase Overview

Identifying Stakeholders & Stakeholder Analysis

Power/Interest Grid & Influence/Impact Matrix

Creating User Personas

Empathy Mapping

The RACI Matrix

Agile Interviews (Discovery, Contextual, Stand-up)

Surveys in Agile Context

Workshops and Facilitation

GenAI for Stakeholder Management

Key Topics :

Introduction to Requirement Prioritization

MoSCoW Method

WSJF (Weighted Shortest Job First)

RICE Scoring Model

Comparing Prioritization Techniques

GenAI for Requirements Management

Requirement Traceability

Requirement Versioning

Requirement Validation

Aligning Requirements with Business Needs & OKRs

Key Topics :

Business Process Modeling Notation (BPMN)

Version Control for Process Diagrams

As-Is and To-Be Process Mapping

SIPOC Analysis

Value Stream Mapping

Customer Journey Mapping

Identifying Bottlenecks and Waste

Automation Opportunities

GenAI for Diagram Generation & Workflow Simulation

Key Topics :

From Process to Requirements

Business Requirements Document (BRD)

Functional Design Document (FDD)

User Story Mapping to Functional Requirements

Integration Scenarios & API Requirements

Non-Functional Requirements (NFRs)

Data Modeling & Schema Design

Requirements Traceability Matrix

GenAI for Requirements Documentation

Linking Requirements to Objectives & OKRs

Requirements Review & Sign-Off Process

Key Topics :

Introduction to Prototyping

Wireframing vs. Mockups vs. Prototypes

Design Thinking for BAs

User-Centered Design Principles

Creating Wireframes (Balsamiq, Figma)

Interactive Prototypes

Usability Testing

Design Validation with Stakeholders

GenAI for UI/UX Design

Key Topics :

BA Role in Testing

Writing Test Scenarios from Requirements

User Acceptance Testing (UAT) Planning

Creating UAT Scripts

Facilitating UAT Sessions

Defect Management & Triage

Acceptance Criteria Validation

GenAI for Test Case Generation

Testing Documentation

Key Topics :

Change Management Fundamentals

Stakeholder Communication Planning

Creating Training Materials

Conducting Training Sessions

User Adoption Strategies

Resistance Management

Communication Cadence & Channels

GenAI for Training Content Creation

Key Topics :

Go-Live Readiness Assessment

Deployment Planning

Cutover Strategy

Super Care Period Planning

Production Support Handoff

Monitoring & Issue Resolution

Post-Implementation Review

Lessons Learned

Key Topics :

Measuring Business Value

KPI Definition & Tracking

Data Analysis for BAs

SQL Basics for Requirements

Power BI / Tableau for Reporting

Process Optimization

Retrospectives & Feedback Loops

GenAI for Data Analysis

BA Career Growth & Specializations

Key Topics :

Software Testing Life Cycle (STLC)

Quality Assurance vs Quality Control

Test-Driven Development (TDD) & Behavior-Driven Development (BDD)

Types of Testing: Functional, Non-Functional, Regression, Smoke, Sanity

Salesforce Architecture for Testing

Salesforce Multi-Tenancy and Release Cycles

Testing Standard vs Custom Objects

Salesforce Sandboxes & Environments

Test Planning & Strategy

Test Data Management

Test Case Design & Management

Test Management Tools (JIRA, Zephyr, TestRail, Azure DevOps)

Key Topics :

Apex Testing Fundamentals

75% Code Coverage Requirement

Test Class Annotations: @isTest, @testSetup

Test Data Factory Pattern

System.assert() Methods

Writing Apex Test Classes

Testing Triggers, Classes, Controllers, and Extensions

Testing Batch, Scheduled, Queueable, and @future Apex

Test Execution & Code Coverage Analysis

Testing Best Practices

Testing Asynchronous Apex

Testing Callouts & Integrations

Mock HTTP Callouts (HttpCalloutMock)

Advanced Apex Testing Techniques

Test Code Refactoring & Maintenance

Key Topics :

Manual UI Testing (Lightning Experience vs Classic)

Testing Page Layouts, Record Types, and Fields

Testing Workflows, Process Builder, and Flows

Testing Lightning App Builder Pages

Responsive Design and Cross-Browser Testing

Lightning Web Components (LWC) Testing with Jest

UI Test Automation with Selenium WebDriver

Locating Elements in Salesforce (XPath, CSS Selectors)

Page Object Model (POM) Design Pattern

Salesforce Test Automation Tools (Provar, Copado, ACCELQ)

Lightning Testing Service (LTS)

UI Test Automation Best Practices

Flow Testing

Key Topics :

Integration Testing (REST, SOAP, Third-Party Apps)

Testing Data Migration and ETL Processes

API Testing with Postman

Security Testing (Profiles, Permission Sets, Roles)

Testing Organization-Wide Defaults (OWD)

Testing Sharing Rules and Field-Level Security

OWASP Top 10 Vulnerabilities in Salesforce

Static Code Analysis (PMD, Checkmarx, SonarQube)

Performance Testing (JMeter, LoadRunner)

Understanding Salesforce Governor Limits

Database Query Optimization

User Acceptance Testing (UAT)

Regression Testing Strategy

Key Topics :

Agentforce Testing Center

AI-Generated Test Cases

Testing AI Agents (Einstein Copilot, Agentforce Agents)

Testing Agent Topics, Actions, and Guardrails

Testing Einstein AI Features

Prompt Engineering Testing

Salesforce DX & CLI for Testing

Continuous Testing & CI/CD

CI/CD Tools (Jenkins, GitHub Actions, Azure DevOps)

Automated Testing in CI/CD Pipelines

DevOps Center (Salesforce Native)

Test Automation Frameworks

Advanced Testing Topics (Multi-Org, Multi-Cloud)

Testing AppExchange Packages

Testing Best Practices & Standards

Test Metrics and KPIs

Emerging Trends (AI-Powered Testing, Shift-Left Testing)

Certification Preparation

Integration Scenarios and Patterns

Integration vs Data Migration

Point-to-Point vs Hub-and-Spoke Architecture

API-Led Connectivity Approach

Integration Patterns: Request-Response, Fire-and-Forget, Batch Sync, Remote Call-In

Salesforce API Landscape: REST, SOAP, Bulk, Streaming, Pub/Sub, GraphQL

API Limits & Best Practices

Governor Limits in Integration Context

Caching, Rate Limiting, and Optimization

OAuth 2.0 Authentication & Flows

Connected Apps Configuration

API Security Best Practices

REST API Fundamentals (RESTful Principles, HTTP Methods)

Salesforce REST API Endpoints

SOQL and SOSL via REST API

CRUD Operations and Composite Resources

SOAP API Deep Dive (WSDL, Enterprise vs Partner)

Bulk API 2.0 Architecture and Operations

Creating Bulk Jobs (Insert, Update, Upsert, Delete)

Error Handling in Bulk Operations

Platform Events (Publishing, Subscribing, Event-Driven Architecture)

Change Data Capture (CDC)

Streaming API (PushTopics)

Pub/Sub API (gRPC-Based Event Streaming)

GraphQL API (Pilot)

Integration Pattern Implementation

Remote Process Invocation (Synchronous & Asynchronous)

Batch Data Synchronization

Apex REST API Development (@RestResource)

HTTP Methods: @HttpGet, @HttpPost, @HttpPut, @HttpPatch, @HttpDelete

URL Mapping & Path Parameters

JSON Serialization & Deserialization

Apex SOAP API Development (webService keyword)

Outbound Apex Callouts (REST & SOAP)

HTTP Classes: Http, HttpRequest, HttpResponse

Named Credentials for Secure Callouts

Asynchronous Callouts (@future, Queueable)

SAP Integration (REST/SOAP APIs, OData Services)

Payment Gateway Integration (Stripe, PayPal, PCI Compliance)

E-Commerce Integration (Shopify, Product Catalog, Order Fulfillment)

ServiceNow Integration (Creating Incidents, Bi-Directional Sync)

Slack Integration (Webhooks, Channels, Interactive Apps)

Error Handling & Resilience

Retry Logic with Exponential Backoff

Circuit Breaker Pattern

Dead Letter Queues

Logging Integration Errors

Testing Integrations (Mock HTTP Callouts, HttpCalloutMock)

Test.setMock() for REST/SOAP

Testing Asynchronous Integrations

Agentforce 360 Integration

Integrating AI Agents with External Systems

MuleSoft Agent Fabric

Creating Agent Actions with External APIs

Real-Time Data for AI Agents

Agent-to-Agent Interoperability

Integration Security Best Practices

OAuth 2.0 Hardening and API Key Management

Secret Management (Named Credentials, External Credentials)

HTTPS & TLS Encryption

Field-Level Encryption and Audit Trail

GDPR & Data Privacy Compliance

Performance Optimization (Bulkification, Caching, Pagination)

Integration Governance (API Versioning, Documentation)

DevOps for Integrations (CI/CD Pipelines, Version Control)

Troubleshooting & Debugging (Debug Logs, Postman, Workbench)

Common Integration Issues (Timeout, Authentication, JSON Parsing)

Topics:

Agentforce Sales Architecture & Evolution

Traditional CRM vs AI-Powered CRM

Agentforce 360 Platform & Data 360 Integration

Atlas Reasoning Engine & Einstein AI for Sales

Leads (Management, Assignment Rules, Conversion, Scoring, Web-to-Lead)

Accounts (Hierarchy, Teams, Planning, Parent-Child Relationships)

Contacts (Roles, Hierarchy, Multiple Contacts)

Opportunities (Stages, Sales Processes, Teams, Products, Close Date)

Activities (Tasks, Events, Activity Management, Timeline)

Sales Pipeline Management

Territory Management (Models, Assignment, Hierarchies, Forecasting)

Sales Process Automation

Workflow Automation & Approval Processes

Sales Path & Guidance Configuration

Sales Cadences (Multi-Touch, Sequencing, Performance Tracking)

Product Catalog & Price Books

Quote Management (Templates, Line Items, PDF Generation)

Topics:

Autonomous Sales Agents vs Chatbots

Agentforce SDR Agent (Lead Qualification, Prospect Engagement, Objection Handling)

SDR Agent Capabilities (Lead Scoring, Personalized Outreach, Multi-Channel Engagement)

Configuring SDR Agent (Topics, Instructions, Qualification Criteria, Guardrails)

Data Cloud Integration & Calendar Integration

Agentforce Sales Coach Agent (Real-Time Coaching, Deal Guidance)

Sales Coach Capabilities (Call Preparation, Competitive Intelligence, Next Best Action)

Configuring Sales Coach Agent (Coaching Triggers, Content, KPIs)

Web-Based Lead Generation Agent

Chat-to-Lead Automation

Sales Agent Development Lifecycle

Agent Testing, Deployment & Monitoring

Trust Layer & Data Security

Agent Guardrails & Compliance

Topics:

Einstein AI Architecture & Trust Layer

Einstein Lead Scoring (Setup, Interpretation, Prioritization)

Einstein Opportunity Scoring (Setup, Interpretation, Deal Prioritization)

Einstein Account Insights (Real-Time Intelligence, News Monitoring, Engagement Signals)

Einstein Activity Capture (Email & Event Capture, Activity Sync, Matching)

Einstein Conversation Insights (Call Recording, Transcription, Analysis, Sentiment)

Einstein Email Insights (Engagement Tracking, Best Time to Send)

Einstein Forecasting (AI-Powered Predictions, Forecast Accuracy, Pipeline Coverage)

Einstein Next Best Action (Personalized Recommendations, Deal Suggestions)

Einstein Relationship Insights (Relationship Health Scoring, Stakeholder Mapping)

Sales Cloud Einstein Analytics

Pre-Built Sales Dashboards (Pipeline, Forecast, Activity, Rep Performance)

Custom Dashboard Creation

Standard & Custom Report Types

Matrix & Joined Reports

Topics:

Sales Performance Management (SPM) & KPIs

Pipeline Velocity, Win Rate, Average Deal Size, Sales Cycle Length, Quota Attainment

Sales Forecasting (Collaborative, Territory-Based, Product Family)

Forecast Categories (Pipeline, Best Case, Commit, Closed)

Forecast Hierarchy & Overrides

Quota Management (Setting, Allocation, Types, Tracking)

Sales Compensation & Incentives (Commission, Bonus, SPIF, Gamification)

Topics:

Advanced Sales Automation with Salesforce Flow

Lead Assignment, Opportunity Auto-Creation, Task Automation

Advanced Approval Processes (Multi-Criteria, Dynamic Routing)

High Velocity Sales (HVS)

Sales Dialer & Email Integration (Gmail, Outlook)

LinkedIn Sales Navigator & Video Conferencing Integration

Data Cloud for Sales (Customer 360 View, Identity Resolution, Segmentation)

Marketing Automation Integration (Pardot, HubSpot, Marketo)

ERP Integration (SAP, Oracle, NetSuite, Order Management)

E-Signature Integration (DocuSign, Adobe Sign)

Communication Platforms (Slack, Microsoft Teams)

External Data Integration (Dun & Bradstreet, ZoomInfo, Clearbit)

Topics:

Agentforce Service Architecture & Evolution

Traditional Support vs AI-Powered Service

Agentforce 360 Platform & Data 360 Integration

Atlas Reasoning Engine & Einstein AI for Service

Cases (Management, Assignment Rules, Auto-Response, Escalation, Web-to-Case, Email-to-Case)

Accounts & Contacts (Customer Account Management, Contact Roles, Account Hierarchy)

Assets & Entitlements (Asset Management, Warranty Tracking, Service Contracts, Milestones)

Knowledge (Articles, Types, Templates, Publishing Workflow, Categories)

Service Console (Navigation, Keyboard Shortcuts, Macros, Utility Bar)

Case Management Best Practices

Case Lifecycle Management & Priority Levels

SLA Management (Entitlement Processes, Milestone Tracking, Violation Alerts)

Case Routing Strategies (Round-Robin, Skills-Based, Load Balancing, Territory-Based)

Knowledge Management (Knowledge Base Building, Article Creation, Validation, Versioning)

Omni-Channel Routing (Presence Statuses, Routing Configurations, Work Assignment Rules)

Topics:

Autonomous Service Agents vs Chatbots

Agentforce Service Agent (Autonomous Case Resolution, 24/7 Support, Intelligent Troubleshooting)

Service Agent Capabilities (Case Creation/Updates, Knowledge Search, Order Status Lookups)

Configuring Service Agent (Topics, Instructions, Resolution Criteria, Guardrails)

Knowledge Base Integration & Case Management Integration

Creating Service Topics (Account Management, Order Status, Billing, Technical Troubleshooting)

Defining Agent Actions (Create Case, Update Case, Search Knowledge, Escalate to Human)

Topic Taxonomy Design & Intent Classification

Multi-Turn Conversations

Service Agent Development Lifecycle

Agent Testing, Simulation, Deployment & Monitoring

Agent Observability & Governance

Trust Layer & Data Security

Compliance (GDPR, CCPA, HIPAA)

Agent Audit Trails

Topics:

Chat and Messaging (Embedded Chat, Chat Bots, Chat Transfers, Chat Routing)

Messaging Channels (SMS, WhatsApp, Facebook Messenger, Apple Business Chat, Google Business Messages)

Slack & Microsoft Teams Integration

Email Integration (Email-to-Case, Email Templates, Email Automation, Email Tracking)

Social Media Engagement (Social Studio, Twitter/X, Facebook, Instagram Support)

Social Listening & Social Case Creation

Voice and Phone (Service Cloud Voice, Call Center Integration, CTI, IVR)

Agentforce Voice for Natural Conversations

Call Recording, Transcription & Analytics

Experience Cloud for Service (Self-Service Portals, Customer Community Setup)

Community Case Management & Knowledge Base in Communities

Mobile Service (Salesforce Mobile App, Field Service Mobile, Mobile Case Management)

Channel Management Best Practices

Einstein Bots (Bot Builder, Bot Dialog Design, Bot Actions, Intents, Handoff)

Topics:

Field Service Lightning (Mobile Workforce Management, Work Orders, Service Appointments)

Service Resources, Service Territories & Operating Hours

Scheduling and Dispatch (Automated Scheduling, Dispatcher Console, Gantt Chart, Optimization)

Mobile Field Service (Field Service Mobile App, Offline Capabilities, Timesheet Management)

Asset Management (Asset Hierarchy, Asset Tracking, Service History, Preventive Maintenance)

Contact Center Integration (CTI, Softphone Integration, Screen Pop Configuration)

Third-Party Contact Center Integrations (Amazon Connect, Five9, Genesys, NICE, Vonage)

Einstein Case Classification (Automatic Case Field Prediction, Case Priority Prediction)

Einstein Article Recommendations (Knowledge Article Suggestions, Next Best Article)

Einstein Reply Recommendations (Suggested Email Responses, Sentiment Analysis)

Einstein Case Wrap-Up (Automatic Case Summary, Resolution Suggestions)

Einstein Conversation Insights (Call Transcription, Topic Identification, Sentiment Tracking)

Service Analytics and Reporting (Service Cloud Dashboards, Pre-Built Reports)

Service Performance Management (AHT, FCR, CSAT, NPS, Case Backlog, SLA Compliance)

Advanced Service Features (Service Entitlements, Service Contracts, Maintenance Plans)

Topics:

Service Automation with Salesforce Flow

Case Auto-Creation, Case Escalation & SLA Violation Flows

Macros (Quick Actions, Multi-Step Macros, Bulk Action Macros)

Process Automation (Case Status Updates, Notification Triggers, Approval Processes)

Service Catalog Automation (Request Fulfillment, Service Request Routing)

CRM Integration (Marketing Cloud, Sales Cloud Handoff, Commerce Cloud)

ITSM Integration (ServiceNow, Jira Service Management, BMC Remedy)

E-Commerce Integration (Shopify, Magento, WooCommerce, Order Management Systems)

Communication Platforms (Slack, Microsoft Teams, Service Alerts)

Survey and Feedback Tools (Salesforce Surveys, NPS Tracking, Post-Case Surveys)

Data Cloud for Service (Unified Customer Profiles, Customer 360 View, Data Harmonization)

Service Cloud Implementation Best Practices

Topics:

Marketing Cloud Studios & Builders Ecosystem

Contact Model vs Subscriber Model

Data Model: Contacts, Subscribers, Data Extensions, Attribute Groups

Multi-Channel Orchestration: Email, SMS, Push, Mobile, Web, Advertising

Agentforce Marketing Architecture & Atlas Reasoning Engine

Marketing AI Agents vs Traditional Automation

Autonomous Agents: Campaign Creation, Content Generation, Journey Optimization

Trust Layer: Grounding, Data Masking, Compliance

Data 360 Integration & Unified Customer Profiles

Marketing Cloud Connect: CRM Integration & Synchronized Data Sources

Setup & Configuration: Business Units, Domain Authentication, Sender Profiles

User Permissions & Access Control

Topics:

Email Studio: Templates, Personalization, Dynamic Content, Subscriber Management

Content Builder: Reusable Blocks, Templates, Brand Assets, Version Control

AMPscript Fundamentals: Variables, Lookups, Conditionals, Data Extensions

Guide Template Language (GTL)

Einstein CoPilot for Marketers & AI Content Generation

Smart Content Recommendations & AI Content Scoring

Predictive Send Time Optimization

A/B Testing & Multivariate Testing

Deliverability: Sender Authentication (SAP, DKIM, SPF), IP Warming

Compliance: CAN-SPAM, GDPR, CASL, Consent Management

Topics:

Journey Builder: Multi-Step, Single Send, Transactional Journeys

Entry Sources: Data Extensions, API Events, Salesforce Objects

Activities: Email, SMS, Push, Wait, Update Contact, Custom Activities

Decision Splits: Attribute, Engagement, Random, Einstein

Multi-Channel Journey Orchestration & Exit Criteria

Path Optimizer & AI-Driven Path Selection

Autonomous Journey Creation with Agentforce

Adaptive Journeys & Predictive Branching

Automation Studio: Scheduled, File Drop, Triggered Automations

SQL for Marketing Cloud: SELECT, JOINS, GROUP BY, Segmentation

Auto-Generated SQL with GenAI

Use Case Patterns: Welcome, Abandoned Cart, Re-Engagement, Post-Purchase

Topics:

Contact Builder: Data Designer, Attribute Groups, Link Relationships

Data Extensions: Types, Primary Keys, Sendable, Retention Policies

Audience Segmentation: Behavioral, Demographic, RFM Analysis

Predictive Segmentation & Look-Alike Modeling

Data Cloud Integration: Unified Profiles, Identity Resolution, DMOs

MobileConnect: SMS/MMS, Short Codes, Keyword Management, TCPA Compliance

MobilePush: SDK Implementation, Push Notifications, Location-Based Messaging

GroupConnect: WhatsApp & Line Integration

AI-Personalized Mobile Messaging

Advertising Studio: Facebook, Instagram, LinkedIn, Google Integration

Web Studio: CloudPages, Smart Capture Forms, AMPscript in Web

LLM-Powered Web Experiences & Micro-Personalized Landing Pages

Topics:

Analytics Builder: Email Tracking, Journey Analytics, Engagement Metrics, KPIs

Einstein AI: Engagement Scoring, Send Time Optimization, Content Selection

Natural Language Analytics & Predictive KPI Modeling

Multi-Touch Attribution & Campaign Forecasting

Marketing Cloud APIs: REST, SOAP, OAuth 2.0, Triggered Sends

Server-Side JavaScript (SSJS): Platform Functions, Data Manipulation, API Calls

API-First Marketing Engineering & Event-Driven Architecture

Advanced AMPscript: Cross-Object Retrieval, Lookup Functions, Error Handling

Building Marketing AI Agents with Agent Builder

Agent Configuration: Topics, Instructions, Testing, Deployment

Marketing Cloud Governance: User Roles, Business Unit Hierarchy, Permissions

Security: Field-Level Security, Audit Trails, GDPR, CCPA, Marketing Cloud Shield

Cross-Cloud Integration: Einstein 1, Data Cloud, CRM, Service

Performance Optimization: Query Tuning, Deliverability, Large-Scale Campaigns

Topics:

Data Cloud to Data 360 Rebrand & Agentforce 360 Ecosystem

Data 360 vs Traditional CDPs

Hybrid Data Lakehouse Platform

Data Lake Objects (DLOs) vs Data Model Objects (DMOs)

Metadata Layer & Real-Time vs Batch Processing

Zero-Copy Data Architecture

Direct Access to Snowflake, Databricks, BigQuery, Redshift

Three Stages: Connect Data, Harmonize & Unify, Analyze & Act

Data 360 & Agentforce Integration

AI Agents Consuming Data 360 Profiles

Agent Fabric & Data Security

Use Cases: Service Agent, Sales Agent, Marketing Agent

Topics:

Data Ingestion: Internal Salesforce, External Cloud, Database Connectors

Application APIs: Shopify, Stripe, NetSuite, Workday

MuleSoft Integration: 300+ Pre-Built Connectors

Real-Time Ingestion API & Pub/Sub API

Data Streams & Data Lake Objects (DLOs)

Ingestion Frequency Configuration & Monitoring

Data Model Objects (DMOs): Standard & Custom

Data Mapping & Transformation

Identity Resolution: Match Rules, Reconciliation Rules

Deterministic vs Probabilistic Matching

Unified Identity Graph & Duplicate Handling

AI-Powered Identity Resolution with Einstein

Intelligent Context for Unstructured Data

Extracting Data from PDFs, Emails, Documents

Multimodal Support & Context Extraction

Topics:

Relationships Between DMOs

Custom Calculated Insights & Derived Attributes

Time-Window Metrics (Last 7/30/90 Days)

Standard Insights: Total Purchases, Average Order Value, Engagement Score

Custom Insights: Industry-Specific KPIs

SQL Queries Within Data 360

AI-Generated Calculated Insights with Einstein CoPilot

Predictive Insights: Churn Probability, Lifetime Value, Propensity Scores

Tableau Semantics: Business Language Layer

Customer 360 Semantic Data Model

Metric Definitions & Making Data "Agent-Readable"

Static vs Dynamic Segments

Behavioral, Demographic & Firmographic Segmentation

RFM Analysis (Recency, Frequency, Monetary)

AI-Powered Predictive Segmentation & Adaptive Segments

Data Quality & Governance

Data Validation Rules & Data Lineage Tracking

Privacy & Consent Management (GDPR, CCPA)

Field-Level Encryption & Masking

Topics:

Data Activation Fundamentals

Activation Targets: Marketing Cloud, Sales Cloud, Service Cloud, APIs

Real-Time vs Batch Activation

Activating Segments to Marketing Channels

Marketing Cloud Journey Builder & Email Personalization

Advertising Platform Integration (Google Ads, Facebook Ads)

SMS & Mobile Push Activation

Data Actions & Triggered Flows

Action Targets: CRM, Marketing Cloud, External APIs

Event-Driven Automation

Real-Time Lead Scoring & Routing

Powering Autonomous AI Agents with Data 360

Connecting Data 360 Profiles to Agentforce

Agent Context: Unified Profiles for Intelligent Responses

Service Agent, Sales Agent (SDR), Marketing Agent Integration

Prompt Builder & Data 360

Dynamic Prompts & Grounding AI Responses

Retrieval Augmented Generation (RAG)

Data 360 for ISVs & Multi-Tenant Scenarios

Topics:

Performance Optimization: Query Tuning, Data Stream Tuning, Caching

Segment Refresh Optimization & Handling Billions of Records

MuleSoft Anypoint Platform & API-Led Integration

System APIs, Process APIs, Experience APIs

Real-Time Data Synchronization & Agent Fabric

Advanced Security & Compliance

RBAC, Object & Field-Level Security

Data Masking, Tokenization & Consent Management

Audit Trail & Zero Trust Architecture

Data Graphs & Relationship Intelligence

Account Hierarchies, Corporate Family Trees & Relationship Scoring

Data Sharing & Zero-Copy Federation

Zero-Copy Sharing with Snowflake & Federated Queries

Data Mesh Architecture Patterns

Monitoring, Troubleshooting & Best Practices

Ingestion Error Handling & Identity Resolution Quality Metrics

Migration from Legacy CDPs to Data 360

Data Migration Planning & Change Management

Industry Use Cases: Retail, Financial Services, Healthcare, Manufacturing, Telecommunications