SB
Spandana Bala
ServiceNow Developer
Hyderabad · India
Now at · Infosys
Class 017 · ServiceNow & AI Agents · Enrolling
Now
ServiceNow
+ AI
Agents
Master end-to-end ServiceNow with Agentic AI. Build the Now Platform foundation in admin, data model, and scripting, ship modern Workspaces with UI Builder and the code-first IDE, and deploy production AI Agents across ITSM, HRSD, CSM, and ITOM with AI Agent.
3mo
duration
30+
modules
4.7/5
class rating
100k+
enrolled
Where our ServiceNow alumni work
Microsoft
Amazon
Salesforce
ServiceNow
Deloitte
Infosys
Accenture
TCS
Wipro
Capgemini
Cognizant
HCL
MicrosoftAmazonSalesforceServiceNowDeloitteInfosysAccentureTCSWiproCapgeminiCognizantHCL
What you leave with
Four things every ServiceNow grad walks away with.
01
Agent-Ready skills
Build, deploy, and monitor AI Agents in AI Agent Studio that drive real production workflows
across the Now Platform — not chatbot demos.
02
A shipped project
A live multi-app ServiceNow implementation (ITSM + AI Agents) deployed via Update Sets and Git,
running on a Personal Developer Instance with a public verification URL.
03
Verifiable credential
2026 Agent-Ready rubric mapped to CSA, CAD, and CIS competencies, graded 1–5, with a public
verification URL recruiters can check in 30 seconds.
04
Direct placement pipeline
GitHub + LinkedIn portfolio rewrite, ServiceNow-tuned resume rebuild, and warm intros into our
1,000+ hiring partners actively staffing ServiceNow + AI Agent roles.
3 months, four phases
From “closes tickets” to ships AI-native ServiceNow workflows..
WEEKS 1–3 · FOUNDATIONS
Platform Admin & Scripting
- Data model, tables, dictionary, ACLs, and impersonation/li>
- Client + server scripting — Business Rules, Client Scripts, UI Policies
- GlideRecord, GlideSystem, Script Includes, GlideAjax patterns
- ITIL 4, Flow Designer, and AI Agent Studio fundamentals
A custom scoped application with full security model, server-side automation, and the
first AI Agent wired into Flow Designer.
WEEKS 4–7 · Modern Development
UI Builder, IDE, and the Now Experience
- Now Experience Framework — components, data binding, state, events
- Custom components with JSX, lifecycle hooks, Now Design System
- VS Code + ServiceNow CLI, TypeScript, Git workflow
- Service Portal, Employee Center, and Agent Workspace integration
A production-grade Workspace built code-first with the ServiceNow IDE, deployed via Git
with full bidirectional sync.
WEEKS 8–10 · Quality & Integrations
ATF, REST, GraphQL, and Integration Hub
- Automated Test Framework with Now Assist for Test Creation
- REST, GraphQL, Scripted REST APIs, OAuth 2.0
- Integration Hub spokes — Teams, Slack, AWS, Azure, Salesforce
- CI/CD with GitHub Actions and Build Agents
YOU SHIPA fully tested, multi-integration ServiceNow application with a Git-driven
CI/CD pipeline replacing manual update sets.
WEEKS 11–12 · GENERATIVE + AGENTIC AI
Deploy AI Agents that automate ITSM, HRSD, CSM, and ITOM workflows across the enterprise.
Use AI Agent Studio, Now Assist, and the AI Agent Orchestrator with Workflow Data Fabric. Build agents that perceive, reason, act, and learn — the four pillars of agentic AI on the Now Platform. Your project connects platform, workspace, integrations, and AI agents into one production-ready ServiceNow solution with a public verification URL.
Partner orgs
(2026)48
Projects
deployed280+
→ Placement
offers82%
Course curriculum
Seven sections. 65+ modules. The AI-native Salesforce & Agentforce stack.
01
ServiceNow Platform Administration
How modern apps work, how teams ship them with Agile, where compute & cloud
fit, and how AI plugs into the 2026 stack.
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
Setting up your Personal Developer Instance (PDI)
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
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
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
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
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
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
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
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
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
02
Web Development Foundations
Front-end fundamentals essential for ServiceNow developers working with
Service Portal, UI Builder, and modern client-side scripting.
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
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
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
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
Objects & ES6+ Features
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
Asynchronous JavaScript
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
03
ServiceNow Scripting
Deep dive into platform scripting — from client-side form behavior to
server-side automation, GlideRecord queries, and reusable Script Includes.
What is platform scripting?
When and why to script (and when *not* to)
Where do scripts execute?
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
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
Reference field names (not labels)
Minimize server lookups for performance
Debugging Client Scripts — browser developer tools, console logging,
troubleshooting
What is a UI Policy? — Defining behavior and visibility of fields on a form
Mandatory, Visible, and Read-only states
UI Policy Configuration — Conditions, execution after Client Scripts,
Reverse-if-false
UI Policy Actions — Set field values, control field visibility, make fields
mandatory
Performance benefits — no scripting required, faster load times, easier
maintenance
When to use — baseline incident form examples, Priority field configuration
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
Configuration & Best Practices
Business Rule Configuration — When to run, conditions, advanced scripting
The `current` and `previous` objects — accessing field values, comparing old vs
new,
`current.update()` and `setAbortAction()`
Business Rule triggers — complex conditions, evaluating previous values, IIFEs
Best practices — preventing recursive Business Rules, order of execution,
performance
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()` — 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
Practical use of GlideSystem methods in Business Rules
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
Advanced GlideRecord
Dot-Walking — accessing reference field properties, multi-level dot-walking,
performance
`GlideRecordSecure` for ACL enforcement
`GlideAggregate` for reporting
`getRowCount()` vs `GlideAggregate`
Server lookup best practices — minimize server lookups, `g_scratchpad`,
`GlideAjax`, GlideRecord
performance impact
Script Include Overview
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
Flow Designer Overview — parity with Workflow, natural language and low-code
approach
Core Concepts — Actions, Subflows, Triggers, Flow Variables
Scripting in Flow Designer — when to add custom scripts, script step
configuration, accessing flow
variables
Action and Subflow easy discovery
Error Handler — catching errors in flows, running actions/subflows on error, error
states
(Completed / Error caught / Error skipped)
Best practices — evaluating core actions before scripting, real-world use cases
04
ServiceNow UI Builder
Build modern, responsive workspaces and portals using the Now Experience
Framework, custom components, and state management patterns.
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
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
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
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
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
05
ServiceNow IDE
> A code-first development experience using VS Code, the ServiceNow CLI, and Git
— featuring a project-based learning path with the Safety Incident Management application.
>
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
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
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
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
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
06
ServiceNow Testing
A comprehensive testing track covering the Automated Test Framework (ATF),
AI-powered test generation with Now Assist, performance testing, CI/CD integration, and User
Acceptance Testing.
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
ATF Overview
What is ATF and its evolution (introduced in Istanbul release)
ATF architecture and components
Benefits — 90% reduction in testing effort
ATF Building Blocks
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)
Test Step Library
Pre-built test step library — Form field validation, button clicks, navigation,
UI element validation, record operations
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 context
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
07
ServiceNow Integrations
Master inbound and outbound integrations using REST, GraphQL, Integration Hub,
and pre-built Spokes for popular enterprise systems.
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
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
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
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
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
08
ServiceNow ITSM Implementation
nd-to-end ITSM implementation covering CMDB, CSDM, the core ITIL processes
(Incident, Problem, Change, Knowledge, Service Catalog), and go-live readiness — with hands-on labs
throughout.
ServiceNow ITSM Platform Introduction
ITIL 4 Best Practices Alignment
Implementation Methodology & Phases
Workshop-Driven Approach (Roadmap, Process, Technical, Requirements)
Stakeholder Management & Change Management
Success Metrics & KPIs
🧪 Lab 1.1 — Setting up your ITSM implementation project plan
CMDB Fundamentals — Why it’s your single source of truth
CI Classes and Configuration Items
Relationships and Dependency Mapping
Discovery and Service Mapping
CMDB Health and Data Quality
Integration with ITSM Processes
CI Class hierarchy and structure
Automated Discovery configuration
Visual Service Maps creation
Impact analysis capabilities
CMDB audit and compliance
🧪 Lab 1.2 — Building and populating your CMDB structure
🧪 Lab 1.3 — Creating CI relationships and service maps
CSDM Framework and 5 Data Domains
Service Hierarchy — Business → Application → Technical → Infrastructure
34 ITIL Practices alignment
CSDM Maturity Model (Foundation → Crawl → Walk → Run → Fly)
Implementing CSDM with CMDB
Business Capability mapping
Business Application vs Application Service
Service modeling best practices
Foundation data requirements
🧪 Lab 1.4 — Designing a CSDM-compliant service structure
🧪 Lab 1.5 — Mapping business services to technical infrastructure
Service Portfolio vs Service Catalog
Service Lifecycle Management
Service Offerings and Tiers
Cost Management and Pricing
Digital Portfolio Management
Creating business and technical services
Service Builder configuration
Performance tracking and KPIs
Integration with Service Catalog
🧪 Lab 2.1 — Building a complete service portfolio
🧪 Lab 2.2 — Configuring service offerings and tiers
Complete Incident Lifecycle
Multi-channel incident creation
Intelligent Assignment and Routing
Priority Matrix configuration
Major Incident Management
AI-Powered capabilities (Now Assist)
Assignment rules and groups
SLA definitions and workflows
VIP user handling
Incident categorization
Resolution workflows
Integration with Knowledge Management
🧪 Lab 2.3 — Configuring incident management workflows
🧪 Lab 2.4 — Setting up assignment rules and SLAs
🧪 Lab 2.5 — Major incident process implementation
Reactive vs Proactive Problem Management
Root Cause Analysis techniques
Known Error Database (KEDB)
Problem Workflow configuration
Integration with Incident Management
Problem identification from incident trends
Problem states and lifecycle
Workaround documentation
Root cause analysis tools
Problem task management
🧪 Lab 2.6 — Implementing problem management workflows
🧪 Lab 2.7 — Creating known errors and linking incidents
Multimodal Change Framework
Normal, Standard, and Emergency Changes
Risk Assessment configuration
Change Advisory Board (CAB) setup
Approval Policies and Workflows
Conflict Detection
Change models configuration
Risk conditions and calculations
CAB Workbench setup
Approval engine configuration
Change calendar and blackout periods
Integration with CMDB for impact analysis
🧪 Lab 3.1 — Configuring change management processes
🧪 Lab 3.2 — Setting up CAB workflows and meetings
🧪 Lab 3.3 — Creating standard change templates
🧪 Lab 3.4 — Implementing approval policies
Knowledge Base architecture
Article types and templates
Lifecycle Management (Creation → Review → Publication → Retirement)
Search optimization
Integration with Incident/Problem/Service Catalog
Knowledge base structure
Approval workflows
Article feedback and ratings
Multi-language support
Knowledge analytics
🧪 Lab 3.5 — Setting up knowledge bases
🧪 Lab 3.6 — Creating article templates and workflows
🧪 Lab 3.7 — Configuring knowledge for incident deflection
Service Catalog structure
Catalog Items vs Order Guides
Request Fulfillment workflows
Approval routing
Portal customization
Catalog Builder
Variable sets and variables
Workflow configuration
Shopping cart functionality
Request fulfillment automation
🧪 Lab 3.8 — Building catalog items and categories
🧪 Lab 3.9 — Creating order guides for onboarding
Integration Hub overview
Email integration for incident/request creation
Third-party tool integrations
Flow Designer for automation
IntegrationHub spokes
Inbound email configuration
REST API integrations
Common integrations (Active Directory, monitoring tools)
Automation best practices
🧪 Lab 4.1 — Configuring email integration for incidents
🧪 Lab 4.2 — Creating automated workflows with Flow Designer
ITSM Dashboards and Reports
Performance Analytics
Key Performance Indicators (KPIs)
Executive scorecards
Custom report creation
Pre-built ITSM dashboards
Report Builder
Scheduled reports
Data visualization
Metric definitions
🧪 Lab 4.3 — Creating ITSM performance dashboards
🧪 Lab 4.4 — Building custom reports for stakeholders
Configuration vs Customization
Update set management
Testing strategies (UAT)
Data migration approaches
Training and communication plans
Phased rollout strategies
Hypercare support planning
Common implementation pitfalls
Platform upgrades and compatibility
Security and access control
Performance optimization
Change management for go-live
🧪 Lab 4.5 — Creating a go-live checklist and plan
Comprehensive Implementation Scenario
Work through a complete ITSM implementation project
Apply workshop methodology
Requirements gathering exercise
Design and configuration decisions
Stakeholder presentations
🧪 Group Exercise — Teams work on implementing ITSM for a fictional company
🎤 Presentation — Each team presents their implementation approach
09
ServiceNow HRSD Implementation
Implement HR Service Delivery from the ground up — including the new Hiring
Experiences suite, Employee Center Pro, Journey Management, and Now Assist AI Agents introduced in
Zurich.
Understanding ServiceNow HR Service Delivery (HRSD) and value proposition
Key features and applications within HRSD
HRSD architecture and security model
Application scoping and its benefits
Licensing packages — Professional vs Enterprise
HRSD platform capabilities and benefits
Application architecture and components
Security model and scoped applications
Global vs scoped applications
Pre-installed plugins and store apps
Roles and access management
🧪 Lab Activities — Navigate HRSD applications, review pre-installed components
HR groups, roles, and skills configuration
Generate and manage HR profiles
Security and governance controls
Advanced work assignment configuration
Secure access to HR Centers of Excellence (COE)
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
🧪 Lab 2.1 — Manage HR Groups and Roles
🧪 Lab 2.2 — Manage HR Skills
🧪 Lab 2.3 — Generate and Manage HR Profiles
🧪 Lab 2.4 — Restricted Caller Access
🧪 Lab 2.5 — Create HR Catalog Items
🧪 Lab 2.6 — Configure Advanced Work Assignment
🧪 Lab 2.7 — Secure Access to HR COE
Brand-new module introduced in the Zurich release. Hiring Experiences replaces the former Talent Acquisition standalone product and is now fully integrated into HRSD Professional and Enterprise SKUs.
Hiring Experiences Suite
The Hiring Experiences suite and its personas: Hiring Manager, Recruiter, Applicant, Interviewer.
Hiring Tab (Manager Hub) — Hiring managers view, track, and decide on
applications;
collaborate with recruiters; available via Manager Hub in Employee Center Pro
Applicant Center — Magic link-based portal for applicants to view
applications, complete
tasks, schedule interviews, communicate with hiring teams, and provide feedback (no password
required)
Recruiter Workspace — Centralized platform with KPI dashboards, job
requisition tracking,
stakeholder collaboration, draft and post requisitions to ATS systems
Interview Management & Scheduling — Structured workflows, flexible scheduling,
applicant
self-scheduling, automated reminders, feedback collection, panelist selection, interviewer
comparison
Integration with external ATS (Applicant Tracking Systems)
Now Assist AI Agents for Hiring (Zurich)
Create Job Requisition (Agentic Workflow) — AI agents gather inputs from
managers via conversational questions, conduct compliance checks, and generate a fully formed job
requisition
Schedule Interview (Agentic Workflow) — AI interprets scheduling intent, finds
optimal time
slots, drafts communications, and handles calendar invites automatically (60%+ time reduction)
Lab Activities
🧪 Configure Hiring Tab in Manager Hub
🧪 Set up Applicant Center with magic link authentication
🧪 Create and manage job requisitions via Recruiter Workspace
🧪 Test Now Assist job requisition creation workflow
🧪 Configure interview scheduling automation
Core Configuration
HRSD tables and components
Core HRSD settings using Guided Setup
Case assignment strategies
Sensitive case handling
Localization and internationalization
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
Zurich Release — HRSD Configure New Features
HR Multi-Instance Integration (HR MII) v2.0 — Centralized HR service
delivery in shared service models across ServiceNow instances; ad-hoc approvals and Universal Tasks
on remote cases; new URL task type; External flag in HR Profile; KB article magic links for consumer
employees; Wrapper HR Services
Document Templates — Enhanced Signing & Filling — PDF template signing on
Mobile Browser and
Now Mobile via ServiceNow Sign, Adobe Sign, and DocuSign; full-tab signing eliminates scrolling;
one-click redirection from Agent Workspace to fill or sign both PDF and HTML templates
Lifecycle Events Logging — Detailed execution logs (Error, Info, Debug levels)
accessible
directly within the case for self-service troubleshooting
🧪 Lab 3.1 — Restricted Caller Access
🧪 Lab 3.2 — Create HR Catalog Items
🧪 Lab 3.3 — Configure Advanced Work Assignment
Employee Center Pro configuration
HR case lifecycle and management
HR services and templates configuration
HR document management
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
🧪 Lab 4.1 — Manage Content on Employee Center Pro
🧪 Lab 4.2 — HR Document Templates
🧪 Lab 4.3 — Create Bulk HR Cases
🧪 Lab 4.4 — Create HR Document Template
🧪 Lab 4.5 — HR Service and HR Case Template
HR Knowledge Management
HR Service Catalog configuration
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
🧪 Lab 5.1 — HR Knowledge Management
🧪 Lab 5.2 — Manage HR Service Catalog
Employee Journey Management framework
Lifecycle Events for Enterprise
Journey Designer and Journey Accelerator
Pre-Hire Experience for early engagement
Growth Experiences (formerly Talent Development)
Alumni Center and offboarding journeys
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
Learning Posts for embedded training
HR integrations architecture
Inbound and outbound integration flows
Pre-built and custom integrations
Integration Hub and Spokes for HR
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
Integration Hub overview
Spokes and their capabilities
Sources, web services, and schema mappings
HR dashboards and reports
Platform Analytics for HR
HR surveys and Listening Posts (deprecation-aware)
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
Now Assist Overview for HRSD
Generative AI vs Agentic AI in ServiceNow HRSD context
Now Assist skills vs AI Agent collections
HR Service Delivery AI Agent Collection (v4) overview
Agentic workflow architecture — AI agents, human oversight, approval gates
Data privacy, governance, and security considerations for AI in HR
Advanced reporting techniques
Performance Analytics deep dive
Business intelligence for HR
Advanced report creation
Custom dashboards
Performance Analytics content packs
KPI definition and tracking
Trend analysis and forecasting
10
ServiceNow CSM Implementation
Implement Customer Service Management across B2C, B2B, B2B2C, and B2B2E models —
covering interactions, cases, products, escalations, Major Issue Management, and Now Assist for CSM.
ServiceNow Customer Service Management overview and value proposition
Key CSM features and applications
CSM architecture and application scoping
Interaction and Case Management processes
End-to-end processes and the “Better Together” principle
Customer service context and definitions
Customer expectations and social media integration
CSM and ITSM integration examples
Application scopes (Global vs Scoped)
Guided Setup for CSM
Plugins and Store applications
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
Portal & Messaging
Configurable Portal widgets
Engagement Messenger
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
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
Case overview and definition
Case State Flows and transitions
Service Level Agreements (SLAs) and SLA Timeline
Special Handling Notes
CSM Configurable Workspace
Workspace navigation and UI components
Case creation and work activity tracking
Form Header and 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
Routing and Assignment
Manual vs automatic routing options
Advanced Work Assignment (AWA) and AWA components
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
Case Tasks
Case Task definition and creation
Case Task assignment
Case Task Service Definitions
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
Case Resolution & Closure
Resolve Case process
Post Case Review — creation, approval workflows, publishing
Close Cases in Resolved State — manual and automatic closure
Customer Satisfaction Surveys — configuration, trigger conditions, distribution
Major Issue Management (MIM)
Benefits and outcomes
Major Case definition
Affected Customers and Recipient Lists
From Case to Major Case workflow
Parent and child Major Cases
Approve and reject Major Cases
Roles and permissions
Targeted Communications
Publication process
Creating Recipient Lists
Building Publications
Publishing with or without approval
Now Assist Overview
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
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 Visualizations
Spotlight for CSM setup
11
ServiceNow ITOM Implementation
Complete IT Operations Management track — CMDB, MID Server, Discovery, Service
Mapping, Event Management, AIOps with Health Log Analytics, Cloud Management, and Service
Observability, all aligned with Zurich-release enhancements.
Introduction to ServiceNow ITOM
What is IT Operations Management?
ITOM vs ITSM — Understanding the difference
ITOM value proposition and business outcomes
ITOM product packages — Visibility, Professional, Enterprise
ITOM Architecture Overview
ServiceNow platform architecture
ITOM application suite components
Data flow and integration points
CSDM (Common Service Data Model) alignment
Zurich Release Highlights for ITOM
AI Agent Fabric and Agent2Agent protocol
Integration Hub with AI Agents
Now Assist for ITOM (Generative AI)
Workflow Data Fabric enhancements
Service Observability expansions
Synthetic monitoring capabilities
CMDB Fundamentals
Purpose and importance of CMDB
Configuration Items (CIs) and CI Classes
CI relationships and dependencies
CMDB data model and class hierarchy
CMDB Design & Architecture
CI Class Manager
Extending the CMDB data model
Normalization and reconciliation rules
Data quality and governance
CMDB Health
CMDB Health dashboard
Health metrics and KPIs
Identification rules
Duplicate detection and management
Orphan CI management
Stale data cleanup
Service Graph Connectors
Third-party data integration
Certified connectors (SCCM, VMware vCenter, AWS Config)
Service Graph import sets
Data transformation and mapping
Hands-On Labs
🧪 Configure CMDB classes and relationships
🧪 Create identification rules
🧪 Set up CMDB Health dashboards
🧪 Implement Service Graph Connector
MID Server Fundamentals
What is a MID Server?
MID Server architecture and components
Communication with ServiceNow instance
Security considerations
MID Server Installation & Configuration
System requirements (Windows / Linux)
Installation procedures
MID Server clustering
High availability configuration
Proxy and firewall considerations
MID Server Operations
MID Server status monitoring
Troubleshooting common issues
MID Server logs analysis
Performance optimization
Upgrade procedures
Credential Management
Credential types and storage
Credential affinity
CyberArk integration for secure credential resolution
SSH key management
Hands-On Labs
🧪 Install and configure MID Server
🧪 Set up MID Server cluster
🧪 Configure credentials and affinity
🧪 Troubleshoot MID Server issues
Discovery Fundamentals
Discovery overview and architecture
Discovery phases (Scanning, Classification, Identification, Exploration)
Probes and Sensors
ECC Queue processing
Discovery Configuration
Discovery schedules
IP ranges and network definitions
Discovery behavior settings
Port probes and protocols (SNMP, SSH, WMI, PowerShell)
Discovery Patterns
Pattern-based discovery
Pattern anatomy and structure
Creating and customizing patterns
Pattern debugging and testing
Horizontal discovery patterns
Cloud Discovery (Zurich Enhancements)
AWS Discovery and credential-free agents
Azure VM discovery with multiple NICs/IPs
GCP resource discovery
Kubernetes discovery
Multi-cloud visibility
Agent Client Collector (ACC)
ACC architecture and deployment
ACC-M (Metrics) and ACC-L (Logs)
Agent-based vs agentless discovery
ACC fleet management
Hands-On Labs
🧪 Configure and run Discovery schedules
🧪 Create custom Discovery patterns
🧪 Set up Cloud Discovery for AWS / Azure
🧪 Deploy Agent Client Collector
Service Mapping Fundamentals
Service Mapping vs Discovery
Business services and application services
Entry points and connection attributes
Service Map visualization
Service Mapping Configuration
Creating application services
Configuring entry points
Top-down vs bottom-up mapping
Service Mapping patterns
Advanced Service Mapping
Dynamic CI Groups
Tag-based service mapping
Cloud service mapping
Container and Kubernetes mapping
Service Mapping Maintenance
Reconciliation with Discovery
Managing mapped services
Service health indicators
Impact analysis
Hands-On Labs
🧪 Create application services with entry points
🧪 Configure top-down service mapping
🧪 Map cloud-native services
🧪 Analyze service dependencies
Event Management Fundamentals
Events vs Alerts
Event lifecycle
Event Management architecture
Integration with monitoring tools
Event Collection & Processing
Connector types (Push / Pull)
MID Server event connectors
REST API event ingestion
Event rules and field mapping
Event transformation
Alert Management
Alert creation from events
Alert correlation rules
Alert aggregation and grouping
Alert severity and priority
Alert remediation workflows
AIOps & Event Management
Predictive AIOps
AI-powered alert correlation
Automated alert grouping
Now Assist for ITOM — Alert Assist
Express List for live alerts
Integrations Launchpad
Service Operations Workspace
Workspace configuration
Dashboard customization
Alert triage workflows
Incident creation from alerts
Hands-On Labs
🧪 Configure monitoring connectors
🧪 Create event rules and mappings
🧪 Set up alert correlation rules
🧪 Configure Service Operations Workspace
Health Log Analytics
HLA architecture
Log data ingestion
Anomaly detection
Predictive AIOps capabilities
Alert generation from log patterns
Metric Intelligence
Metric collection and storage
Adaptive thresholds
Anomaly detection on metrics
Heat maps and visualization
Integration with ACC-M
Operational Intelligence
Machine learning models
Pattern recognition
Capacity planning
Performance trending
Hands-On Labs
🧪 Configure HLA data inputs
🧪 Set up metric anomaly detection
🧪 Create custom dashboards for metrics
Orchestration Fundamentals
Orchestration vs Flow Designer
Workflow activities
MID Server orchestration
Credential requirements
Flow Designer for ITOM
Subflows and actions
ITOM-specific flows
Error handling
Approval processes
Playbooks & Remediation
Automated remediation workflows
Self-healing infrastructure
Runbook automation
Integration with Change Management
Zurich Automation Enhancements
Agentic playbooks
AI-driven orchestration
Integration Hub with AI Agents
Cross-enterprise workflow automation
Hands-On Labs
🧪 Create automated remediation flows
🧪 Build ITOM playbooks
🧪 Configure self-healing scenarios
Cloud Provisioning & Governance
Cloud Management architecture
Cloud accounts configuration
Resource catalogs
Provisioning workflows
Cloud Cost Management
Cloud spend visibility
Cost optimization recommendations
Budget alerts
Chargeback / showback
Multi-Cloud Management
AWS, Azure, GCP integration
Unified cloud dashboard
Policy enforcement
Compliance management
Hands-On Labs
🧪 Configure cloud account integration
🧪 Create cloud catalog items
🧪 Set up cost management dashboards
Service Observability Overview
Unified service health view
Integration with third-party APM tools
No-migration data approach
Observability Integrations
Datadog integration
Dynatrace integration
Splunk integration
New Relic integration
AppDynamics integration
Synthetic Monitoring
Website and API monitoring
Response time checks
Response body validation
MID Server-based checks
Instance-based checks
Hands-On Labs
🧪 Configure Service Observability
🧪 Set up synthetic monitoring
🧪 Create unified health dashboards
Tools you'll master
25+ ServiceNow & AI tools, one production project.
Real-time projects
You don't watch videos. You ship software.
Three full-production projects, each threaded through the entire curriculum. By the project, you've built the whole stack around them.
Hero project · weeks 3–12
ITSM agent on Now Assist
Build an end-to-end Service Desk on ITSM — Virtual Agent intake, Flow Designer routing, and a Now Assist co-pilot that summarises incidents, suggests resolutions, and writes work notes for agents.
01Live ITSM tenant with incident, request & problem workflows wired through Flow Designer.
02Virtual Agent topic that intakes from the portal & Slack and routes to the right assignment group.
03Now Assist co-pilot that summarises incidents, drafts customer updates, and auto-fills work notes.
04AI Agent Studio agent that closes recurring L1 tickets — password resets, access requests — with zero human touch.
Outcome: ~55% L1 deflection
Avg. resolution: −42%
Reviewer: Elite Partner panel
ITSMNow AssistVirtual AgentFlow
DesignerAI Agent Studio
Enterprise · weeks 6–11
HRSD onboarding agent
Ship an Employee Center onboarding journey — HRSD cases, IntegrationHub flows to Workday, and an AI agent that answers policy questions and provisions accounts on day one.
HRSDEmployee CenterIntegrationHubGlideScript
Real-time · weeks 8–12
ITOM incident auto-triage
Stream events from MID Server and observability tools into Event Management, classify with Predictive Intelligence, and auto-create ITSM incidents with AI-drafted impact summaries.
ITOMEvent ManagementPredictive IntelligenceMID Server
Project · weeks 11–12
Your AI ServiceNow agent in a real partner org.
Pick a real partner workflow. Deploy a production agent into a ServiceNow tenant — Now Assist + AI Agent Studio — that handles tickets, drafts updates, and accelerates resolution.
Download the real world project
Full scope, sample partner orgs, weekly milestones, and grading rubric — PDF, 14 pages.
2026: 220+ deployed76% → placement offers
Your instructor
Taught by engineers who shipped agentic AI to production.
MK
Manikanta Kona
Founder, Digital Lync · Enterprise AI Architect
ServiceNow · Now Assist · AI Agent Studio · ITSM / ITOM / HRSD / CSM
"ServiceNow at enterprise scale is where AI agents earn their keep — Now Assist plugged into the Service Desk, AI Agent Studio orchestrating ITSM, ITOM, HRSD, and CSM as one fabric. That's the bar I teach to, every cohort."
15 yrs
SERVICENOW
2,400+
LEARNERS
4.9 /5
RATING
Manikanta is the founder of Digital Lync and brings 15 years of enterprise platform architecture from AT&T, Salesforce, Cox Communications, and Broadcom — where he led ITSM, ITOM, HRSD, and CSM rollouts for Fortune-500 banks, telcos, and insurers. Most recently he architected production Now Assist + AI Agent Studio deployments that replaced traditional triage tiers with autonomous case-handling.
His classes get you two things other programs don't give you: a founding architect who's shipped enterprise ServiceNow + AI from inside the Fortune 500, and a curriculum rewritten every release (currently Zurich) — so when hiring managers ask about CMDB Workspaces, AI Agent Studio sub-flows, or ITOM Visibility, you've already built it. M.S. in Engineering, Purdue University.
RK
Ravi Krishna
Chief Technologist, Digital Lync · ITOM Lead
ITOM · AIOps · CMDB · Discovery · Event Management · MID Server · DevOps
"ITOM is where ServiceNow stops being a ticket tool and starts being the nervous
system of the enterprise — Discovery feeding a CMDB you actually trust, Event Management that's quiet
on purpose, and AIOps + Now Assist resolving incidents before on-call gets paged. That's what I teach."
10 yrs
ITOM & OPS
1,800+
LEARNERS
4.8 /5
RATING
Ravi is Chief Technologist at Digital Lync, where he leads the ITOM and operations-engineering practice. After 8 years building and running production DevOps pipelines, he stepped into the Chief Technologist seat to wire AIOps, Now Assist, and Discovery into the way operations teams actually work — CMDB that stays accurate through change windows, Event Management that filters noise before it hits humans, and Service Operations Workspace that on-call engineers don't fight with.
His ITOM modules are built from real outage post-mortems, not slide decks. Expect to leave with working Discovery patterns, Event Management rule packs, MID Server topology, and a CMDB you can stake an SLA on. Ten years at Digital Lync, eight of them shipping DevOps in production — Hyderabad-based, hands-on, and known for the unglamorous parts of ServiceNow that everyone else skips.
HIRING PARTNERS · INDUSTRY VOICES
What ServiceNow employers say about Digital Lync grads.
Real feedback from talent leaders at ServiceNow Elite Partners and the firms hiring our ServiceNow + AI Agents graduates.
Digital Lync grads ramp 40% faster on Now Assist projects than typical hires. Best ServiceNow training pipeline in India.
Aakash Mehta, Partner Programme Lead, ServiceNow
We've onboarded 80+ Digital Lync alumni in 18 months. Lowest ramp time we've seen for ServiceNow plus AI agent practices.
Anita Sharma, Senior Manager, Deloitte
The ServiceNow programme is comprehensive — admin, developer, plus AI agent flows. Grads come pre-trained for enterprise.
Rahul Bhatt, Solutions Lead, Mphasis
Their ITSM + Now Assist track produces engineers who write production-grade Flow Designer flows on day one. Genuinely rare.
Deepak Pillai, Senior Architect, TCS
What sets Digital Lync apart is the AI Agent Studio layer baked into the ServiceNow track. Our enterprise clients ask for exactly this profile.
Suresh Menon, Practice Lead, Accenture
Their CSA + CAD prep is rigorous, and the project deployment on a real PDI is what closes interviews for us.
Vikram Iyer, Director, Infosys
Digital Lync's ServiceNow grads close incidents twice as fast in the first 90 days. Our internal metrics back this up clearly.
Lakshmi Nair, VP Engineering, Wipro
Best ServiceNow + AI Agents pipeline we've sourced from in India. Their projects are production work, not toy code.
Karthik Subramanian, Engineering Director, Cognizant
Strong HRSD and Employee Center foundation. Their ServiceNow grads need almost zero ramp time on enterprise engagements with us.
Arun Joshi, Practice Director, Capgemini
We've placed 40+ Digital Lync alumni across our ServiceNow and watsonx-on-Now teams. Strong fundamentals, sharp on the agent stack.
Sanjay Verma, Talent Director, IBM
ITOM + Predictive Intelligence is exactly the talent gap we've been struggling to close. Digital Lync is filling it for us reliably.
Anjali Desai, Practice Head, LTIMindtree
Their ServiceNow track delivers consultants who navigate ITSM, IntegrationHub, and Flow Designer on customer engagements unsupervised.
Ramesh Iyer, Senior Manager, Tech Mahindra
Hired 25+ Digital Lync graduates for our ServiceNow practice. Strong scripting, strong platform depth, sharp on the agent layer.
Geetha Pillai, Talent Acquisition Lead, Cyient
Digital Lync grads who blend Now Assist with Azure OpenAI land production-ready on day one. Rare combination, well-trained.
Priya Reddy, Talent Lead, Microsoft
03Program certifications
An Agent‑Ready credential, not a participation trophy.
Digital Lync · Institute Certificate
Agent‑Ready ServiceNow Engineer
Presented to
Spandana Bala
For the successful design, build, and production deployment of an AI agent on the
ServiceNow Now Assist + AI Agent Studio platform, evaluated against the 2026 Agent‑Ready rubric and
CSA / CAD competencies.
Manikanta Kona
CEO · Digital Lync
AGENT
READY
2026
READY
2026
01
Industry‑recognized
Co‑branded with the ServiceNow Elite Partner ecosystem and mapped to CSA, CAD and CIS —
names that hiring managers already scan for on resumes.
02
Project artifact included
Every certificate carries your project project name, the partner org, and a link to the
deployed Now Assist + AI Agent Studio artifact — proof, not a promise.
03
Enhanced skill validation
Graded against the 2026 Agent‑Ready rubric: ITSM design, Flow Designer build, Now Assist
deployment, safety and monitoring. No pass/fail — a level 1‑5 band.
04
Verifiable on a public URL
Each credential has a public verification page recruiters can check in 10 seconds — no PDF
back‑and‑forth.
04Job placement support
Your first ServiceNow offer isn't a lottery ticket. It's a built process.
GitHub, LinkedIn, resume — and most importantly, warm intros into ServiceNow Elite Partners. Our
placement team works your search like an account, not a helpdesk.
01 / GITHUB PROFILE
A portfolio, not a graveyard.
Guidance on building a GitHub that showcases your Update Sets, Now Assist + AI Agent Studio project, Flow Designer flows, and a working PDI link — reviewed 1:1, not via template.
02 / RESUME PREP
Rewrite, don't proofread.
A one-page resume rebuilt around the ServiceNow modules you implemented (ITSM, HRSD, ITOM), the agent you deployed, and the business outcome. Reviewed by engineers who've read 10,000+ resumes.
03 / LINKEDIN + INTROS
Where most opportunities actually live.
Profile tuning plus direct warm introductions into the ServiceNow Elite Partner network — Infosys, TCS, Deloitte, Accenture, Cognizant, NTT Data, Capgemini. You leave with recruiter contacts, not a generic "good luck."
ServiceNow alumni
Hundreds of ServiceNow careers launched — here are eight.
NV
Naveen Vedala
ITSM Consultant
Hyderabad · India
Now at · TCS
TA
Tejashwini Addla
HRSD Specialist
Hyderabad · India
Now at · Deloitte
TD
Tharunesh Dillikar
ServiceNow Architect
Seattle · United States
Now at · ServiceNow
MM
Mujahed Mohammed
Lead ServiceNow Engineer
Hyderabad · India
Now at · Accenture
BK
Bhargav Kumar Murala
Now Assist Developer
Hyderabad · India
Now at · Capgemini
SL
Sai Manasa Leburi
ITOM Engineer
New York · United States
Now at · NTT Data
RD
Rahul Dhamma
AI Agent Studio Engineer
Hyderabad · India
Now at · Cognizant
Our locations
Come chat with us — over coffee, or over Zoom.
One flagship campus in Hyderabad, plus online ServiceNow classes running on Indian and US timezones.
Flagship campus
Hyderabad
2nd Floor, Hitech City Road · Above Domino's · Opp. Cyber Towers, Jai Hind Enclave ·
Hyderabad, Telangana
Call
+91 90003 29956
US desk
+1 858 666 6719
Hours
Mon–Sat · 9am–9pm
Online class
Global
Weekend and evening ServiceNow classes running on IST and PST. Every online cohort ships
the same three production projects and Now Assist + AI Agent Studio project as the on‑campus track.
Timezones
IST & PST
Format
Live + 1:1 mentorship
Next class
25 May 2026
FAQ
Questions we actually get — answered honestly.
Straight answers on prerequisites, the platform, certifications, and placement. If something's missing, book a 20-minute advisor call — no slides, no pitch.
Do I need a CS background or prior ServiceNow experience?
No on both counts. Roughly 40% of every class comes from non-CS streams — mechanical, electrical, BCom, BBA — and zero ServiceNow exposure is assumed. Weeks 1–2 cover the platform model, tables, and GlideScript from scratch. What you do need: consistency and 12–15 hours a week.
Do I get a real ServiceNow developer instance to work on?
Yes. Every learner provisions a free Personal Developer Instance (PDI) from week 1 and keeps it for the full program. Every lab, project, and the project are built on your own live tenant — not a sandbox simulator — so the artifacts you ship are demonstrable to recruiters.
Which ServiceNow modules and AI tools will I actually build with?
Core: ITSM, HRSD, ITOM, Service Portal, IntegrationHub, Flow Designer. AI track: Now Assist (case summaries, work-note generation, code assist), AI Agent Studio for agentic flows, Predictive Intelligence for classification, and Virtual Agent for conversational intake.
Will I be ready for CSA, CAD and CIS certifications?
Yes. The curriculum is mapped to CSA (Certified System Administrator) and CAD (Certified Application Developer); enterprise-track learners also prep for CIS-ITSM or CIS-HR. We run two full mock exams and reimburse the voucher fee on first-attempt pass.
What's the time commitment per week?
Plan for 12–15 hours: 2 live classes × 2 hours, 1 lab × 3 hours on your PDI, and ~5 hours of project work. Saturday office hours with the TA team are optional, but most learners use them.
Is placement support really 1:1, and which companies hire?
Yes — a dedicated placement advisor from week 8, not a helpdesk. ServiceNow hiring partners include Infosys, TCS, Deloitte, Accenture, Cognizant, NTT Data, Capgemini, plus the ServiceNow Elite Partner network. Resume, LinkedIn, mock interviews, and warm intros are individual.
Online, weekend, or on-campus?
All three. On-campus at the Hyderabad flagship, live online (IST and PST cohorts), and a weekend track for working professionals. Every format ships the same three projects and the same project — only the schedule changes.
What if I fall behind, or can't continue mid-class?
Freeze your seat for up to 90 days and rejoin the next class — no extra fee. TAs run catch-up sessions every Saturday for anyone more than a week behind, and recordings of every live session are available for the lifetime of your account.
Still have a question? Talk to an advisor — no slides, no pitch.
Class 025 starts 25 May 2026.
40 seats. 12 already claimed.
Book a 20-minute advisor call. We'll walk through the curriculum, match it to your current role, and show you two real projects from class 022.
