ServiceNow Training with AI Agents

Key Topics:

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 Topics :

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

Key Topics :

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)

Creating custom tables and fields

Import Sets for data integration

Update Sets for configuration migration

Key Topics :

User administration and management

Groups for organising 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

Key Topics :

Client-side vs Server-side scripting

Configuration vs Customization

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 Topics :

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 Topics :

Understanding flows and workflows

Types of flows: User, Data, Process, Logic

Manual vs Digital workflows

Levels of automation: Basic, Process, Intelligent

Autonomous systems vs simple automation

ServiceNow Flow Designer

Playbooks and Workflow Studio

Real-world automation scenarios

Key Topics :

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 and AI models (LLM, SLM)

Building and configuring AI agents

Real-world applications across IT, HR, Customer Service, Security

Key Topics :

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)

Report governance and best practices

Key Topics :

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

Application Repository for version control

App Engine and Studio

Key Topics :

Introduction to Web Development & Client-Server Architecture

HTML Document Structure & Semantic HTML5

Text, Links & Media Elements

Lists & Tables

Forms & Input Elements with Validation

Accessibility Best Practices

Key Topics :

CSS Fundamentals & Selectors (Specificity)

Box Model, Typography & Colors

Layouts & Positioning

Flexbox for One-Dimensional Layouts

CSS Grid for Two-Dimensional Layouts

Responsive Design & Media Queries

Transitions & Animations

CSS Variables & Modern Features

Key Topics :

JavaScript Basics & Integration with HTML

Variables (let, const) & Data Types

Operators (Arithmetic, Comparison, Logical)

Control Flow (if/else, switch)

Loops (for, while, do-while, for...in, for...of)

Functions (Declaration, Expression, Arrow Functions)

Scope & Hoisting

Key Topics :

Advanced Functions (Arrow Functions, IIFE)

Callbacks & Higher-Order Functions

Closures & Function Scope

Recursion

Arrays: Creating, Accessing, Modifying

Mutating Methods (push, pop, splice, sort)

Non-Mutating Methods (slice, concat, join)

Array Iteration (forEach, map, filter, reduce, find, some, every)

Destructuring & Spread Operator

Key Topics :

Objects: Creating, Accessing, Methods

Object Destructuring & Spread Operator

Object Methods (keys, values, entries, assign)

Template Literals & Multi-line Strings

Enhanced Object Literals

Computed Property Names

ES6+ String Methods

Symbols & Iterators

let, const & Block Scope

Synchronous vs Asynchronous JavaScript

Call Stack, Web APIs & Event Loop

Callbacks & Callback Hell

Promises (Creating, Chaining, Handling Errors)

Promise Methods (all, race, allSettled, any)

Async/Await Syntax

Error Handling with try/catch

Fetch API for HTTP Requests

Working with REST APIs

Local Storage & Session Storage

Key Topics :

What is platform scripting?

Why should you not script? When should you script?

Where do scripts execute?

Who can script?

How do you script in ServiceNow?

Introduction to Application Scope

Condition Builder vs JavaScript

Client-side vs Server-side scripting overview

Mozilla Rhino JavaScript engine

ECMAScript 2021 (ES12) standards

Scoped vs Global applications

ServiceNow APIs overview

The Syntax Editor and Context-Sensitive Help

Key Topics :

**Client Script Types:**

onLoad Client Scripts - Form initialization and default values

onChange Client Scripts

Field-level validation and auto-population

onSubmit Client Scripts

Final validation and confirmation

onCellEdit Client Scripts - List view inline editing

**Client-side APIs:**

g_form object methods

g_user object methods

g_scratchpad for client-server data passing

**Best Practices:**

Referencing field names (not labels)

Minimizing server lookups

Client-side performance optimization

**Debugging Client Scripts:**

Browser developer tools

Console logging techniques

Common errors and troubleshooting

Key Topics :

**What is a UI Policy?**

Defining behavior and visibility of fields on a form

Mandatory, Visible, and Read-only states

**UI Policy Configuration:**

Condition must be true for execution

Executes after Client Scripts

Reverse if false option

**UI Policy Actions:**

Set field values

Control field visibility

Make fields mandatory

**Performance Benefits:**

No scripting required for basic cases

Faster load times vs Client Scripts

Easier maintenance

**When to Use:**

Baseline incident form examples

Priority field configuration

Key Topics :

**Business Rule Fundamentals:**

Server-side scripts that run on record operations

When to run: Insert, Update, Delete, Query

**Business Rule Types:**

**Before Business Rules** - Data validation and field population

**After Business Rules**

Related record updates

**Async Business Rules**

Background processing without blocking

**Display Business Rules** - Query/display optimization

**Query Business Rules**

Filter records

**Business Rule Configuration:**

When to run (Insert/Update/Delete/Query)

Conditions for execution

Advanced checkbox for scripting

**The current and previous Objects:**

Accessing field values

Comparing old vs new values

Using current.update() and setAbortAction()

**Business Rule Trigger:**

More complex conditions and actions can be scripted

Evaluating previous values

Immediately invoked function expressions

**Best Practices:**

Preventing recursive Business Rules

Order of execution

Performance considerations

Key Topics :

**Common GlideSystem Methods:**

gs.log() - Logging for debugging

gs.addInfoMessage() - User feedback messages

gs.addErrorMessage() - Error notifications

gs.warn() - Warning messages

**User Information Methods:**

gs.getUserID() - Get current user ID

gs.getUserName() - Get current username

gs.getUser() - Get user object

**Date and Time Methods:**

[gs.now](http://gs.now)() - Current date/time

gs.nowDateTime() - Current datetime object

gs.daysAgo() - Calculate past dates

gs.beginningOfLastMonth() - Date calculations

**Events in ServiceNow:**

gs.eventQueue() - Trigger events

Event-driven automation

**Module Notes:**

GlideSystem methods can be included in any server-side script

Practical use in Business Rules

Key Topics :

**GlideRecord Fundamentals:**

Server-side database queries

The four-step pattern: Create → Query → Loop → Process

**CRUD Operations:**

**Create:** initialize() and insert()

**Read:** query() and next()

**Update:** setValue() and update()

**Delete:** deleteRecord() and deleteMultiple()

**Query Building:**

addQuery() with operators (=, !=, ,>, LIKE, IN, etc.)

addEncodedQuery() for complex conditions

addNullQuery() and addNotNullQuery()

orderBy() and orderByDesc()

setLimit() for performance

**Dot-Walking:**

Accessing reference field properties

Multi-level dot-walking

Performance considerations

**Advanced GlideRecord:**

GlideRecordSecure for ACL enforcement

GlideAggregate for reporting queries

getRowCount() vs GlideAggregate

**Server Lookup Best Practices:**

Minimize server lookups

Use g_scratchpad for client-server data passing

GlideAjax for dynamic data retrieval

GlideRecord performance impact

Key Topics :

**Script Include Overview:**

Not many configuration options

Runs server-side only

No default objects available

Data (parameters) passed from calling script

Must be called to run

**Script Include Configuration:**

Name - Script Include name (no spaces/special characters)

API Name - Scope and script name

Glide AJAX enabled (Client callable)

Mobile callable

Sandbox enabled

Application scope

Accessible from (Global vs Scoped)

Active checkbox

Description

**Script Include Types:**

**Classless Script Includes** - Simple reusable functions

**Class-based Script Includes** - OOP approach with initialize()

**Client-callable Script Includes** - GlideAjax integration

**Calling Script Includes:**

From Business Rules

From other Script Includes

From Client Scripts via GlideAjax

From UI Actions

From Scheduled Jobs

**GlideAjax Pattern:**

Creating client-callable Script Includes

Asynchronous server-side data retrieval

Callback functions and response handling

Passing parameters between client and server

Key Topics :

**Flow Designer Overview:**

Reached parity with Workflow

Natural language and low-code approach

Easy for many roles to use

**Core Concepts:**

**Actions** - Reusable business logic across flows

**Subflows** - Reusable sequences within flows

**Triggers** - What initiates the flow

**Flow Variables** - Data storage and passing

**Scripting in Flow Designer:**

When to add custom scripts

Script step configuration

Accessing flow variables in scripts

Action and Subflow easy discovery

**Error Handler:**

Catching errors in flows

Running actions/subflows on error

Error Handler switch (enable/disable)

Error Handler section configuration

Error status details (Code and Message)

Error states: Completed (error caught), Completed (error skipped), Error

Up to 10 items in Error Handler section

**Best Practices:**

Evaluate core actions before scripting custom logic

Real-world use cases and scenarios

Why, when, and how often to use these capabilities

Key Topics :

Introduction to UI Builder and modern web development

UI Builder vs. Traditional Development (Service Portal, Classic UI)

Now Experience Framework (UXF) and component architecture

UI Builder Interface: Canvas, component panel, configuration

Preview modes (Desktop, Tablet, Mobile)

Pages, variants, and URL routing

Component Library: Layout, data display, input, navigation

Creating and configuring your first page

Key Topics :

Component anatomy: properties, data bindings, events, styles

Working with Data Resources: Look Up, Create, Update, Delete, Aggregate

Query conditions, filtering, and optimization

Data Binding: syntax, expressions, one-way and two-way binding

Client State Management: creating, managing, and passing state

Data Brokers for server-side scripts

Dynamic Lists, Repeaters, and collections

Forms and Input Handling with validation

Conditional Rendering and role-based visibility

Performance optimization and caching strategies

Key Topics :

Custom component architecture (HTML/JSX, JavaScript, CSS)

Creating components: structure, properties schema, JSX templates

Component Properties: types, validation, defaults

Component Events: dispatching, handlers, event-driven communication

Component Lifecycle hooks (mount, update, unmount)

State Management: component-level state and immutable patterns

Styling: component-scoped CSS and Now Design System

Working with Data: HTTP effects, API calls, error handling

Advanced Patterns: compound components, render props, HOCs

Testing: unit testing, rendering, event handling

Key Topics :

State architecture levels: component, page, application, session

Complex state structures: objects, arrays, nested state

Computed properties and data transformation

Event handling: types, propagation, handler patterns

Form State Management: multi-step forms, validation, workflows

Async State: loading states, error handling, optimistic updates

Event Bus Pattern for cross-component messaging

URL State Management and deep linking

State Debugging with DevTools

Performance optimization: memoization, debouncing, throttling

Key Topics :

Platform Integration: Agent Workspace, Employee Center

Flow Designer Integration and execution patterns

Service Catalog Integration: custom forms and workflows

REST API Integration: consuming and creating endpoints

Security & Access Control: RBAC, input validation, XSS prevention

Application Deployment: Dev → Test → Prod workflow, Update Sets

Version Control: Git integration and branch strategies

Performance Optimization: lazy loading, code splitting, caching

Accessibility (a11y): WCAG compliance, keyboard navigation, ARIA

Testing Strategies: unit, integration, cross-browser testing

Monitoring & Analytics: performance, usage, error tracking

Best Practices: code organization, documentation, security

Key Topics :

What is ServiceNow IDE: code-first approach and modern development

Evolution: Platform UI → Studio → IDE

ServiceNow IDE vs. Studio: comparison and use cases

IDE Architecture: VS Code, CLI tool, Git integration

IDE Development Workflow: Initialize → Develop → Build → Deploy → Test → Iterate

When to Use IDE vs. Studio and hybrid approaches

Benefits for developers, teams, and organizations

IDE Limitations and infrastructure requirements

Getting started checklist and prerequisites

Course Project: Safety Incident Management Application

Key Topics :

Software Installation: VS Code, Git, ServiceNow CLI

VS Code Extensions: ServiceNow Extension Pack and productivity tools

Workspace Setup: structure, organization, configuration files

Instance Connection: Basic Auth, OAuth, multiple instances

Creating Your First Application: wizard, package.json, tsconfig.json

VS Code Configuration: snippets, IntelliSense, formatting, linting

Testing the Setup: verification, CLI, build, deployment

Key Topics :

Application Folder Structure: directories, organization, build output

The index.ts File: entry point, table definitions, metadata

Defining Tables and Fields: syntax, field types, validation

Server-Side Code: business rules, script includes, API endpoints

Client-Side Code: client scripts, UI policies, form behaviors

Using Third-Party Libraries: npm packages, type definitions

Metadata Explorer: browsing, pulling records, converting UI to code

Key Topics :

Application Development Workflow: Design → Develop → Build → Deploy → Test → Iterate

Building the Safety Incident Application: requirements, data model, business rules

Implementing script includes and client scripts

Building and Deploying: compilation, transpilation, deployment

Testing in Instance: verification, validation, integration testing

Debugging Techniques: VS Code debugging, breakpoints, troubleshooting

Syncing Changes: bidirectional sync, conflict resolution

Working with UI Components and Service Portal

Testing Strategies: Jest, integration, mock data, automation

Performance Optimization and profiling

Documentation: standards, README, API docs

Key Topics :

Git Version Control: why Git, Update Sets limitations, workflows

Initializing Git Repository: .gitignore, commits, remote setup

Branch Strategy: GitFlow, main/develop branches, feature branches

Sync Capability: instance to IDE, metadata sync, conflict resolution

Converting Existing Applications: assessment, migration, refactoring

Multi-Instance Deployment: Dev → Test → Prod workflows

CI/CD: pipeline architecture, GitHub Actions, automation, quality gates

Metadata Explorer: advanced operations, bulk operations

Rollback and Recovery: Git strategies, versioning, disaster recovery

Best Practices: deployment checklists, verification, security

Overview of ServiceNow architecture and instances

Key modules: ITSM, ITOM, HRSD, CSM, ITAM

Understanding the Now Platform and metadata-driven architecture

ServiceNow release cycles

ROI of automated testing: 90% reduction in testing effort

**Unit Testing:** Testing individual components (scripts, business rules)

**Functional Testing:** Validating business logic and workflows

**Integration Testing:** Verifying interactions between modules and external systems

**Regression Testing:** Ensuring existing features work after changes

**Performance Testing:** Assessing speed and reliability under load

**Security Testing:** Identifying vulnerabilities and data protection

**User Acceptance Testing (UAT):** Business validation of requirements

**Agentic AI Testing:** Testing AI agents and autonomous workflows

What is ATF and its evolution (introduced in Istanbul release)

Benefits: 90% reduction in testing effort

ATF architecture and components

**Test Suites:** Containers grouping related test cases

**Test Cases:** Individual scenarios with sequences of steps

**Test Steps:** Building blocks (Open Form, Set Field Values, Click Button)

**Test Templates:** Predefined step lists for common scenarios

**Test Data:** Parameterized data sets for multiple test runs

**Reusable Tests:** Modular test components (NEW in Yokohama)

Pre-built test step library:

Form field validation

Button clicks and navigation

UI element validation

Record operations (Create, Read, Update, Delete)

**Server-side test steps:** Business rules, script includes, workflows

**Client-side test steps:** UI policies, client scripts, form interactions

**API test steps:** REST/SOAP endpoint validation

**Declarative Action test steps:** Visibility and click actions

Introduction to Reusable Tests feature

Benefits: DRY principle, reduced duplication, improved consistency

JavaScript coding in ATF

Script includes for test logic

Best practices for maintainability

**Workflows and Flow Designer:** Approval chains, task routing

**Service Catalog:** Catalog items, variables, order guides

**SLAs:** Start, pause, stop conditions testing

**Notifications and Emails:** Verifying email triggers

**Business Rules:** Server-side script validation

**Client Scripts and UI Policies:** Form behavior testing

Recording test steps through UI interaction

Handling workspace URLs and navigation

Testing Agent Workspace and Service Operations Workspace

Overview of Generative AI in ServiceNow testing

Now Assist for Test Creation feature

Benefits: Reduced test creation time, accessibility for non-technical users

Generating ATF tests from natural language prompts

Writing effective test descriptions

AI-powered test step prediction

Self-healing test scripts

Predictive test coverage analysis

Autonomous testing capabilities

AI agents for test maintenance

Understanding AI Agent Studio (Yokohama Release)

AI Agent Orchestrator for managing multiple agents

Types of AI agents: ITSM, CSM, HR, SecOps

Pre-built vs. custom AI agents

Validating AI agent behavior and responses

Testing agentic workflows and decision-making

Verifying AI agent tool integrations

Optimize knowledge base data for AI Search

Monitor performance with analytics dashboards

Testing supervised vs. autonomous execution modes

Introduction to Performance Profiling feature

Setting up performance tests

Warmup runs and sequential execution

Cloud Runner for consistent baseline results

Analyzing performance metrics

Performance comparisons across releases

**Gatling:** Scalable load testing framework

**BlazeMeter:** Cloud-based performance testing

**Tricentis NeoLoad:** ServiceNow-specific performance testing

Identifying real-world user scenarios

REST API Explorer for testing

Validating endpoints, authentication, and payloads

Testing data exchange and integrity

Automating API tests with ATF

Inbound and outbound integrations

Testing transform maps and import sets

Third-party system integrations

MID Server connectivity validation

Error handling and retry mechanisms

Understanding CI/CD in ServiceNow contex

App Engine Studio and scoped applications

ServiceNow Studio enhancements (Zurich)

GitHub Actions for ATF (sncicd-tests-run)

Automated test triggers on code commits

Introduction to Build Agents for external CI/CD

Automated build, test, and deployment workflows

Replacing manual update set exports

Best practices for Build Agent implementation

Deployment pipeline automation

Pipeline visibility and traceability

Bi-annual release cycles (Q1 and Q3)

Recent releases: Xanadu → Yokohama → Zurich

Types of changes: API updates, schema changes, UI modifications

Cloning production to sub-production environment

Instance backup and rollback strategies

Running regression test suite

Go/No-Go decision criteria

Defining UAT scope and objectives

Creating test scenarios from business requirements

Identifying test personas and roles

Building test plans and scripts

Preparing testers and communication

Capturing test evidence (screenshots, documentation)

Pass/Fail criteria and actual results

Defect management and resolution

Business sign-off and acceptance

Topics:

What is Integration?

Integration types: Inbound, Outbound, and Bidirectional

Integration components: Endpoints, Payloads, Headers, Authentication

Data formats: JSON, XML, CSV

Integration methods in ServiceNow

Step-by-step integration process

Real-world use cases and best practices

Key terminology and glossary

Topics:

REST architecture principles

HTTP methods: GET, POST, PUT, PATCH, DELETE

REST components: Endpoints, Headers, Body, Status Codes

Authentication methods: Basic Auth, OAuth 2.0, API Keys

Request/Response lifecycle

Error handling and retry logic

Rate limiting and performance optimization

Testing with Postman and REST API Explorer

Real-world integration scenarios

Topics:

ServiceNow Table API

ServiceNow Import Set API

ServiceNow Aggregate API

Scripted REST APIs

Real-world use cases:

Employee onboarding automation

IT support ticket automation

Meeting room booking systems

Emergency response integration

Executive dashboards

Mobile app integrations

Performance optimization techniques

Security considerations

Topics:

What is GraphQL and why use it?

GraphQL vs REST comparison

GraphQL components: Schema, Query, Resolver

Queries, Mutations, and Subscriptions

GraphQL in ServiceNow

GraphiQL Explorer tool

Real-time data with subscriptions

Performance benefits and use cases

Building dashboards with GraphQL

Mobile app optimization

Topics:

Integration Hub architecture

Flow Designer fundamentals

Understanding Spokes and Actions

Pre-built spokes:

Microsoft Teams

Slack

JIRA

AWS

Azure

Salesforce

Connection and credential management

Creating custom actions

Error handling in flows

Monitoring and troubleshooting

Real-world automation scenarios

Topics:

CMDB Fundamentals and Architecture

CI Class hierarchy and structure

Configuration Item relationships

Dependency mapping and impact analysis

Automated Discovery configuration

Visual Service Maps creation

CMDB health dashboards

Integration with Incident, Problem, Change

CMDB audit and compliance

Data quality management strategies

Topics:

CSDM Framework introduction

Foundation domain: Companies, locations, users

Design domain: Business capabilities, applications

Build domain: Development artifacts

Manage Technical Services domain

Sell/Consume domain: Service offerings

Business Capability mapping

Business Application vs Application Service

Service modeling best practices

CSDM maturity assessment

CSDM Data Foundations Dashboard

Topics:

Service Portfolio Management fundamentals

Service vs Service Offering distinction

Service taxonomy structure

Portfolio lifecycle management

Service Builder configuration

Service commitments and SLAs

Cost management and pricing models

Performance tracking and analytics

Integration with ITSM processes

Digital Portfolio Management workspace

Topics:

Incident Management process flow

Multi-channel incident creation (Email, Portal, Chat, API)

Assignment rules and routing logic

Priority matrix configuration

SLA definitions and tracking

Major Incident Management procedures

VIP user handling

Incident categorization strategies

Resolution workflows

Integration with Knowledge Management

Incident closure and auto-close configuration

Surveys and feedback collection

Topics:

Problem Management fundamentals

Reactive problem management

Proactive problem management

Problem identification from incident trends

Root Cause Analysis (RCA) methodologies

Known Error Database management

Workaround documentation

Problem states and lifecycle

Problem task management

Integration with change management

Problem analytics and reporting

Topics:

Change Management fundamentals

Multimodal change models

Normal change workflow

Emergency change expedited process

Standard (preapproved) change catalog

Risk assessment and risk conditions

Risk calculation and scoring

Change Advisory Board (CAB) workbench

CAB meeting management

Approval engine and policies

State transitions and conditions

Conflict detection configuration

Blackout and maintenance schedules

Change calendar management

Integration with CMDB for impact analysis

Topics:

Knowledge Management fundamentals

Knowledge base structure and design

Article types and templates

Knowledge lifecycle (Creation → Review → Publication → Retirement)

Approval workflows

Article quality standards

Search optimization techniques

Multi-language support

Knowledge analytics and metrics

Integration with incident deflection

Article feedback and ratings

Knowledge-Centered Service (KCS) methodology

AI-powered article recommendations

Topics:

Service Catalog fundamentals

Catalog structure and categories

Catalog items vs Record producers

Order guides for bundled requests

Variable types and variable sets

Catalog Builder for business users

Request fulfillment workflows

Approval routing configuration

Shopping cart functionality

Portal customization

Employee Center integration

Request analytics and reporting

SLA configuration for requests

Topics:

Now Assist Overview:

Generative AI in ServiceNow

Now Assist capabilities and benefits

AI model training and customization

Data privacy and security considerations

Incident Management with Now Assist:

AI-powered incident summarization

Automated resolution notes generation

Intelligent incident categorization

Similar incident detection

AI-suggested knowledge articles

Automated root cause analysis

Virtual Agent Enhancements:

Conversational AI capabilities

Natural language understanding

Context-aware responses

Dynamic topic routing

Sentiment analysis

Automated ticket creation from conversations

Knowledge with Now Assist:

AI-powered article generation

Automated article updates

Knowledge gap detection

Search query understanding

Article quality scoring

Case Management with AI:

Automated case summarization

Next-best-action recommendations

Workload prediction

Agent assist in real-time

Performance optimization suggestions

Predictive Intelligence:

Predictive categorization

Priority prediction

Assignment prediction

Resolution time estimation

Trend analysis and forecasting

Topics:

Integration Hub overview

Email integration for incident/request creation

Third-party tool integrations (Active Directory, Monitoring)

REST API integrations

Flow Designer for automation

IntegrationHub spokes

Common integrations (AD, SCCM, Monitoring tools) **Reporting & Analytics:**

ITSM dashboards and reports

Performance Analytics configuration

Key Performance Indicators (KPIs)

Executive scorecards

Custom report creation

Report Builder mastery

Scheduled reports

Data visualization best practices

Metric definitions **Implementation Best Practices:**

Configuration vs Customization principles

Update set management

Testing strategies (UAT)

Data migration approaches

Training and communication plans

Phased rollout strategies

Hypercare support planning

Change management for go-live **Go-Live Planning:**

Go-live checklist creation

Cutover planning

Rollback procedures

Communication plan

Support model

Success metrics definition **Common Pitfalls:**

Over-customization risks

Platform upgrades and compatibility

Security and access control

Performance optimization

Topics:

HRSD platform capabilities and benefits

Roles and access management

Application architecture and components

Security model and scoped applications

Global vs scoped applications

Pre-installed plugins and store apps

Topics:

HR organizational structure and roles

HR skills management

Case assignment options (Assignment Rules, Matching Rules, AWA)

HR profiles vs user records

Delegated development

COE security configuration

Locking down HR administration

Topics:

HRSD table structure and COE tables

HR Guided Setup wizard

HR properties configuration

Case assignment methods (Templates, Rules, AWA)

Agent Workspace for HR Case Management

Employee Relations and Anonymous Report Center

I18N and localization considerations

Topics:

Employee Center Pro setup and content management

Content Publishing and Campaigns

HR case creation and workflow

Universal Request for HR

HR services and categorization (COE, Topic Category, Topic Details)

HR templates and task types

Response templates

HR document templates (HTML and PDF)

E-signature and document generation

Employee Document Management (EDM)

Bulk HR case creation

Topics:

HR Knowledge base structure and organization

Knowledge article creation and management

Roles and responsibilities (Owners, Managers, Contributors)

Knowledge translations and localization

User criteria and access control

HR Catalog major components

Catalog item creation using Manage HR Catalog

Variables and variable sets

Record producers

Topics:

Employee Journey Management overview

Lifecycle Events Enterprise vs standard

Activity sets and activities

Activity triggers and audience targeting

Activity containers and field mapping

Journey Designer integration

Journey Accelerator plans and templates

Journey template management and delegation

Bulk task management

Listening Posts for employee feedback

Learning Posts for embedded training

Topics:

ServiceNow integration categories

HR integrations plugin and capabilities

Inbound integration process flow (pull data)

Outbound integration process flow (push data)

Pre-built integrations (e.g., First Advantage)

Custom integration configuration

ESM Integrations Framework

Spokes and their capabilities

Sources, web services, and schema mappings

Topics:

HR dashboards (Overview, Manager, Agent)

Report Designer and report creation

Service Level Agreements (SLAs)

Platform Analytics vs Reporting

Data collection jobs and KPI scorecards

HR survey configuration

Survey Designer and trigger conditions

Assessment metrics and categories

Pulse surveys and themes

Pulse dashboards and analytics

Topics:

Now Assist for HR overview

AI-powered case categorization with Predictive Intelligence

Virtual Agent integration

Natural Language Understanding (NLU) for HR

Agent Assist capabilities

Topics:

Advanced report creation

Custom dashboards

Performance Analytics content packs

KPI definition and tracking

Trend analysis and forecasting

Topics:

Customer service context and definitions

ServiceNow CSM basic concepts

Customer expectations and social media integration

Interaction and Case Management process

CSM and ITSM integration examples

Applications and features overview

Application scopes (Global vs Scoped)

Guided Setup for CSM

Plugins and Store applications

Topics:

Business models and customer data models overview

**B2C (Business-to-Consumer):**

Consumer records and Consumer Users

Households and household members

Consumer addresses and address types

Consumer Service Portal access and self-registration

**B2B (Business-to-Business):**

Customer Accounts and account hierarchy

Contacts and contact relationships

Account addresses

Business Portal access and self-registration

**B2B2C & B2B2E:**

Multi-level data models

Account Consumer relationships

Configurable Portal widgets

Engagement Messenger

Topics:

Interaction definition and management

Omni-channel process flow for interactions

Customer interaction capabilities

Interaction state transitions

Lookup and Verify functionality

Customer Central

Response Templates

Email-to-Interaction process flow

Virtual Agent with NLU (Natural Language Understanding)

Agent Chat capabilities

CSM Configurable Workspace for live agents

Public and private chat conversations

Quick actions and Conversation Autopilot

Topics:

Product Model Management:

Products vs Services definitions

Product types (tangible and intangible)

Product Model tables and hierarchy

Product Model characteristics

Install Base Management:

Sold Products

Install Base Items and Installed Products

Install Base hierarchy

Tracking Install Base Item attributes

Contracts and Entitlements:

Contract definitions and management

Entitlement selection process

Entitlement workflows

Topics:

Case overview and definition

Case State Flows and transitions

Service Level Agreements (SLAs)

Service Level Agreement Timeline

Special Handling Notes

CSM Configurable Workspace:

Workspace navigation and UI components

Case creation and work activity tracking

Form Header configuration

Form Ribbon configuration

Contact Time Zone and Follow the Sun features

Case Types:

Case Types definition and architecture

When to use Case Types

Case Type configuration

Case Type hierarchy

Topics:

Routing and Assignment:

Manual vs automatic routing options

Advanced Work Assignment (AWA)

AWA components and configuration

Agent Affinity (Historical, Related task, Account Team)

Case Initiation as an Agent:

Case creation methods

Service Definitions and Case Types

Service Selector and Case Type Selector

Case through Service Catalog:

Service Catalog configuration

Record Producers

Contextual search during Case creation

Service Definitions with Record Producers

Topics:

Case Tasks:

Case Task definition and creation

Case Task assignment

Case Task Service Definitions

Service Definitions with Case Tasks

Case Action Status and Blocking Tasks:

Action Status indicators

Blocking Tasks configuration

Pre-configured flows

Case Summaries:

Case Action Summary creation

Publication and notification options

Escalations:

Escalation benefits and outcomes

Case and Account escalations

Escalation process flow

De-escalation process

Roles for managing escalations

Topics:

Resolve Case process

Post Case Review:

Post Case Review creation

Approval workflows

Publishing Post Case Review documents

Close Cases in Resolved State:

Manual Case closure

Automatic Case Closure with flows

Customer Satisfaction Surveys:

Survey configuration

Trigger Conditions

Survey distribution methods **Major Case Management:**

Major Issue Management (MIM):

Benefits and outcomes

Major Case definition

Affected Customers and Recipient Lists

From Case to Major Case workflow

Roles and permissions

Targeted Communications:

Publication process

Creating Recipient Lists

Building Publications

Publishing with or without approval

Topics:

Introduction to Now Assist for CSM

AI and Generative AI capabilities

Benefits and value proposition

Integration with CSM workflows **Agent Assist Features:**

Case summarization with AI

Intelligent response suggestions

Similar case recommendations

Knowledge article suggestions

Sentiment analysis and customer intent detection **Automation and Productivity:**

Automated case categorization and routing

AI-powered workflow automation

Predictive case resolution

Agent productivity analytics **Configuration and Setup:**

Now Assist enablement and licensing

Configuration best practices

Training AI models for CSM use cases

Security and privacy considerations

Topics:

Persona-Based Dashboards:

Benefits and outcomes of metrics

Performance Analytics for CSM

Responsive Dashboards overview

Dashboard by Persona:

Customer Service Agent Dashboard

Customer Service Manager Dashboard

Customer Service Executive Dashboard

Case Spotlight

CSM Dashboard Configuration:

Data sources for dashboards

Analytics Hub usage

Platform Analytics vs Data Visualisations

Spotlight for CSM setup