ServiceNow
+ AI Agents

What You'll Learn: Understanding ServiceNow and the Now Platform Cloud computing fundamentals and where ServiceNow fits (SaaS → aPaaS) ServiceNow technology stack and architecture Platform concepts: instances, environments, data model Product portfolio across IT, Employee, Customer, and Business workflows CSA certification path and learning resources Key Takeaways: Why enterprises invest in ServiceNow Platform architecture and core concepts Career pathways and market opportunities Setting up your Personal Developer Instance (PDI)

What You'll Learn: ServiceNow interface layout: Banner, Navigator, Content Frame Working with Lists (multiple records) and Forms (single records) Using Global Search, Filters, and Breadcrumbs Personalization (user-level) vs Configuration (admin-level) Configuring lists, forms, choice lists, and reference fields Organizing navigation with Applications and Modules UI branding and customization Zurich theme enhancements and dark mode support Key Takeaways: Master the ServiceNow interface Configure user experiences for different roles Design intuitive navigation structures Brand the platform for your organization

What You'll Learn: Understanding data, databases, tables, records, and fields The role of sys_id in ServiceNow Types of tables: Base, Extended (inheritance), Custom Relationships: Extending vs Referencing Exploring the data model: Tables, Dictionary, Schema Map Data types and field types in ServiceNow CMDB (Configuration Management Database) foundations Creating custom tables and fields Import Sets for data integration Update Sets for configuration migration Zurich Data Quality improvements Key Takeaways: Design robust data models Understand ServiceNow's relational architecture Import external data safely Move configurations between instances

What You'll Learn: User administration and management Groups for organizing people and work assignment Roles as bundles of permissions Access Control Lists (ACLs) for data security ACL operations: Create, Read, Write, Delete ACL evaluation process and best practices Implementing least privilege security Testing access with impersonation Delegation for temporary access management Key Takeaways: Design secure, role-based access Implement proper security governance Balance security with usability Audit and validate access controls

What You'll Learn: Client-side vs Server-side scripting Configuration vs Customization best practices UI Policies for no-code form behavior Client Scripts for browser-based logic Business Rules for server-side automation UI Actions for custom buttons and links Data Policies for server-side validation Script Includes for reusable code Choosing the right tool for each requirement Key Takeaways: Implement business logic effectively Balance no-code and scripted solutions Understand when to use each customization tool Write clean, maintainable scripts

What You'll Learn: ITIL 4 framework and Service Value System (SVS) The 7 ITIL Guiding Principles The Four Dimensions of Service Management 34 ITIL 4 practices and ServiceNow mapping Core ITSM processes: Incident, Problem, Change, Request Service Desk, Knowledge Management, and Service Catalog ITIL metrics and KPIs ITIL certification path Key Takeaways: Align ServiceNow with ITIL best practices Understand why ServiceNow is structured as it is Design processes that follow proven patterns Speak the language of IT service management

What You'll Learn: Understanding flows and workflows Types of flows: User, Data, Process, Logic Manual vs Digital workflows Levels of automation: Basic, Process, Intelligent, Autonomous ServiceNow Flow Designer Workflow Studio (Zurich) with Help me decide guidance Playbooks for guided process execution Reusable Scheduled Triggers and External Webhook Triggers (Zurich) Real-world automation scenarios Key Takeaways: Design efficient workflows Automate repetitive tasks Understand the evolution from manual to autonomous Build flows that improve business outcomes

What You'll Learn: Understanding AI Agents vs traditional automation The four pillars: Perceive, Reason, Act, Learn Agentic AI architecture and framework AI Agent Orchestrator and specialized agents Workflow Data Fabric for unified data access Now Assist capabilities and AI models (LLM, SLM) Building and configuring AI agents Agentic Playbooks (Zurich) Real-world applications across IT, HR, Customer Service, Security Key Takeaways: Leverage AI for autonomous problem-solving Build agents that work collaboratively Integrate AI with existing workflows Understand the future of enterprise automation

What You'll Learn: Reporting vs Performance Analytics Report types: Bar, Pie, Line, List, Pivot, Gauge, Score Building reports with Report Designer Analytics Q&A (natural language queries) Creating and configuring dashboards Performance Analytics: Indicators, Breakdowns, Data Collections KPIs and metrics by process (Incident, Change, Request, Problem) User Experience Analytics (Zurich) Report governance and best practices Key Takeaways: Turn data into actionable insights Create reports that drive decisions Build dashboards for different audiences Track performance trends over time

What You'll Learn: Why build custom apps in ServiceNow Application development lifecycle Three design layers: Business, Data, and UI ServiceNow platform architecture (layer cake) Scoped development process Building tables, forms, workflows, and reports for custom apps Update Set deployment and Application Repository App Engine Studio Build Agent (Zurich): natural language app creation Developer Sandboxes for isolated development Key Takeaways: Extend ServiceNow beyond out-of-box apps Design apps that solve real business problems Follow structured development processes Deploy apps safely across environments

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)

List Collections (Declaration, Initialization, Methods) Set Collections (Unique values, Methods) Map Collections (Key-Value pairs, Iteration) Nested Collections Collection Best Practices & Performance Optimization

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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

Go-Live Readiness Assessment Deployment Planning Cutover Strategy Super Care Period Planning Production Support Handoff Monitoring & Issue Resolution Post-Implementation Review Lessons Learned

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

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)

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

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

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

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)

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)

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

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

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)

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)

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

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

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

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

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

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

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

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

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

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