Connection & Credential Aliases
Guide for creating ServiceNow Connection & Credential Aliases (sys_alias) using the Fluent API. Use when the user mentions connecting to external systems, storing or managing credentials, integrating with external databases, managing connections across multiple environments, authentication configuration, or shared integration settings with parent-child inheritance. Do NOT use system properties or custom tables to store connection details or credentials — use aliases instead.
Connection & Credential Alias Templates
Guide for creating Connection & Credential Alias Templates (sysaliastemplates) using the
Application Menus
Guide for creating ServiceNow Application Menus and Modules using the Fluent API. Application menus define top-level sections in the ServiceNow navigator sidebar, and modules define the clickable items within them.
Assignment Rules
Guide for creating ServiceNow Assignment Rules using the Fluent API. Assignment rules automatically populate empty assignmentgroup or assignedto fields on task or task-inherited tables after a record is saved to the database. Assignment rules do not run if these fields already have values. They execute after the insert or update operation completes.
Implementing Tests Guide
Create ServiceNow Automated Test Framework (ATF) test cases using Fluent APIs across 13 ATF categories: server, form, REST, catalog, email, app navigator, reporting, responsive dashboard, uiTestScript (custom UI), list and related list operations, and Service Portal variants (formSP, catalogSP). This guide covers test strategy, category selection, step configuration, and the full API surface for each ATF namespace.
UI Test Script (TestingLibrary) Guide
Author ATF tests for custom UI components using atf.uiTestScript.runTest() and the TestingLibrary API. Use this when a UI cannot be tested through the standard atf.form. or atf.catalog. steps — Angular/React widgets embedded in workspaces, custom SPAs or UI-page apps, and now-* web components. The test body runs in the client test runner with all API globals injected, so no imports are needed inside the script.
Building AI Agents — Advanced Guide
Advanced patterns for AI Agent and Agentic Workflow development: instructions authoring, authentication and ACL configuration, validation rules, error recovery, deployment procedures, and anti-patterns to avoid.
Building AI Agents Guide
Build and configure ServiceNow AI Agents and AI Agentic Workflows using the Fluent SDK. AI Agents perform tasks with tools (CRUD, script, OOB, reference-based), while AI Agentic Workflows orchestrate multiple agents as a team. This guide covers agent structure, authentication, triggers, ACL deployment, and workflow configuration. Requires SDK 4.4.0 or higher.
Building AI Agents — Tools Guide
Configure and select tools for ServiceNow AI Agents and AI Agentic Workflows using the Fluent SDK. Covers tool types (CRUD, script, OOB, reference-based, RAG), tool discovery, execution mode, output transformation, and multi-tool composition patterns.
Business Rules
Guide for creating ServiceNow Business Rules using the Fluent API. Business rules are server-side scripts that run automatically when records are queried, updated, inserted, or deleted.
ChoiceSet Guide
Guide for adding choices to table fields using the ChoiceSet API. Use this when your app needs to extend choices on a field it does not own — typically a globally-defined field inherited by an app-scoped table that extends a global table.
Client Scripts
Guide for creating ServiceNow Client Scripts using the Fluent API. Client scripts run JavaScript in the browser on form events to configure forms, fields, and field values while the user is interacting with them.
Client-Side APIs
Reference for ServiceNow client-side APIs available in the browser. These APIs are shared across all Fluent APIs that execute client-side scripts — Client Scripts, UI Policy scripts (scriptTrue/scriptFalse), UI Actions (client-side), Catalog Client Scripts, and Catalog UI Policies.
Creating Workspaces Guide
Guide for creating ServiceNow Workspaces -- complete out-of-the-box solutions for managing business entities through standardized CRUD workflows. A workspace automatically generates a dashboard page, list management views, and detailed forms following ServiceNow's standard UX patterns.
Cross-Scope Privileges
Guide for creating ServiceNow Cross-Scope Privileges using the Fluent API. Cross-scope privileges declare that your application needs to access resources (tables, script includes, scriptable objects) owned by a different application scope.
Data Lookup
Guide for creating ServiceNow Data Lookup definitions (dl_definition) using the Fluent API. A Data Lookup connects a source table to a configurable matcher table and defines which source fields are used to find a matching row and which values are copied back to the source record. In simple terms form field change, record insert, and record update. If you find yourself reaching for a Business Rule (for insert/update) plus a Client Script (for onChange) to implement the same deterministic field-population logic, use Data Lookup instead.
Data Policy
Guide for creating ServiceNow Data Policies (sysdatapolicy2) using the Fluent API. Data policies enforce field mandatory and read-only rules server-side across all interfaces — forms, imports, web services, and APIs — and cannot be bypassed, unlike client-side UI Policies.
Developing ServiceNow Apps with the Now SDK
Guide for ServiceNow app development using the Now SDK: project setup, fluent authoring, build/deploy workflow, and CLI reference. Start here when working on a new ServiceNow application or with the Now SDK before consulting artifact-specific guides.
Email Notification Guide
Create ServiceNow Email Notifications (syseventemailaction) to send automated emails based on database operations, custom events, or manual triggers. This guide covers trigger types, content formats, recipients, digest emails (batched notifications), templates, styles, scripts, access restrictions, and notification categories. Supported in SDK 4.3.0 or higher.
Encoded Queries
How to build well-formed ServiceNow encoded query strings — the compact field-operator-value syntax used by most condition and filter fields across the Fluent APIs (Business Rules, ACLs, SLAs, Data Policies, UI Policies, Email Notifications, Flow triggers, and more) and by now-sdk query --query.
Configuring External Services Guide
Guide for configuring external LDAP directory connections in ServiceNow, including LDAP Server Configs (ldapserverconfig) and LDAP Server URLs (ldapserverurl) for failover and load balancing. Use when the user mentions LDAP server configuration, directory servers, Active Directory, OpenLDAP, LDAP failover, or LDAP SSL. For LDAP data imports (staging tables, data sources, transform maps), see the importing-data-guide topic instead. Supported in SDK 4.2.0+.
Field Styles
Guide for creating ServiceNow Field Styles using the Record API. Field styles apply CSS styling to fields in list and form views based on field values or scripted conditions.
ServiceNow Fluent Overview
ServiceNow Fluent is a domain-specific language (DSL) based on TypeScript for defining the metadata files [sys_metadata] that make up applications. It includes APIs for tables, roles, ACLs, business rules, Automated Test Framework tests, and more.
Form Formatters
Guide for adding formatters to ServiceNow forms using the Form API. Formatters display special UI components (activity streams, process flows, knowledge panels, checklist, parent breadcrumb) that are not regular table fields.
Form Layout
Guide for creating ServiceNow form layouts using the Form API. Forms define which fields, annotations, formatters, and embedded lists appear on a record's form view and how they are arranged.
GraphQL APIs
Guide for creating ServiceNow scripted GraphQL APIs using the Fluent API. A GraphQL API pairs an SDL schema with resolvers that fetch field data, secured by a schema-gate ACL for the whole API and field-level path-based ACLs enforced at query time.
Importing Data
Guide for importing external data into ServiceNow using the Fluent API. Covers Data Sources, staging tables, Import Sets (transform maps), and the three-component pattern required for every data import.
Inbound Email Actions
Guide for creating ServiceNow Inbound Email Actions using the Fluent API. Inbound email actions define how ServiceNow processes incoming emails — creating records, updating existing records, sending auto-replies, or running custom logic when emails are received.
Instance Scan Guide
Create ServiceNow Instance Scan checks using Fluent API. Covers all scan check types: TableCheck, LinterCheck, ColumnTypeCheck, and ScriptOnlyCheck. Instance scan checks evaluate an instance for upgradability, performance, security, manageability, and user experience issues. Supported in SDK 4.0.0 or higher.
JavaScript Compatibility
Reference for ECMAScript features supported on the ServiceNow server-side JavaScript engine. For the full per-feature matrix, see the official JavaScript engine feature support documentation.
Knowledge Base Access Controls Guide
This guide explains how to configure who can read and who can contribute to a ServiceNow Knowledge Base using Fluent. It covers the four M2M tables that link knowledge bases to user criteria, with examples for granting, denying, and replacing access entries.
List Controls
Guide for creating ServiceNow List Controls using the Record API. List controls configure the visibility and behavior of list UI elements — buttons (New, Edit), filters, links, inline editing, and pagination — based on roles or conditions.
Lists
Guide for creating ServiceNow list layouts using the List API. A list defines which columns appear when users view table records in list/table view. Each List() call creates a sysuilist record and its associated sysuilist_element records on the target instance.
JavaScript Modules
JavaScript modules are the modern, preferred approach for all server-side code in Fluent projects. Modules support import/export, provide access to typed Glide APIs via @servicenow/glide, enable code reuse across your application, and integrate with third-party npm libraries.
AI Skills — Advanced Guide
Advanced configuration for AI Skills: provider and model discovery, security controls, deployment options, skill URL construction, validation rules, and troubleshooting. Read the companion AI Skills Guide for core concepts (inputs, tools, prompts, complete examples).
AI Skills Guide
Create and configure AI Skills using the NowAssistSkillConfig API in the Fluent SDK. Skills use configured prompts to generate AI responses from an LLM, optionally enriched by inputs and tools (script, inline script, web search, subflows, flow actions, decision branches). This guide covers skill structure, inputs, prompts, deployment, and naming conventions. Requires SDK 4.6.0 or higher.
AI Skills — Tools Guide
Complete reference for configuring tools in NowAssist / GenAI Skills. Tools fetch or manipulate data before prompt processing — use them when a skill needs data beyond user inputs, such as querying records, searching the web, running business logic, or integrating with flows.
NPM Library Compatibility
Reference of npm libraries tested in the Australia release of the ServiceNow platform. For the authoritative list, see the official Third-party library support documentation. Libraries are categorized into three tiers: supported, limited support, and unsupported.
Overriding Inherited Columns
Guide for using OverrideColumn to modify properties of columns inherited from a parent table. When you extend a table using extends, you inherit all columns from the parent. Use OverrideColumn to change how these inherited fields behave on the child table without modifying the parent table's definition.
Playbook Activities Guide
An activity is a single step inside a playbook lane — present a form to a user, send an email, update a record,
Playbook Anti-Patterns Guide
Wrong/correct code examples for the most common playbook mistakes. Pair this with playbook-guide (mental model + execution errors and gotchas) — that doc covers the conceptual errors; this one shows the structural mistakes that cause silent failures or compile errors.
Playbook datapills guide
Practical guide for configuring datapills in playbook, which allows you to reference runtime values during playbook execution.
Playbook Guide
Conceptual guide for understanding how the Playbook DSL works, including execution ordering, decision branching, and common errors. For API signatures, interfaces, and type definitions see playbook-api.md.
Playbook Lanes Guide
Practical guide for configuring playbook lanes — covers restart rules, conditional execution, start delays, and common lane layouts. For the underlying type signatures see playbook-api; for execution-ordering concepts see playbook-guide.
Playbook Patterns Guide
Recipes for the most common playbook shapes — simple single-lane workflows, multi-lane sequential and parallel layouts, and decision-driven branching (including chained decisions and stage-level routing between lanes). Each pattern is shown end-to-end so it can be copied as a starting point. For activity and lane reference material see playbook-activities-guide and playbook-lanes-guide.
Playbook permissions guide
Practical guide for granting access to a playbook, its lanes, and its activities. Permissions control who can view, launch, restart, and manage a playbook and act on the stages/lanes and activities inside it at runtime, expressed declaratively in Fluent.
Playbook Triggers Guide
Practical guide to the trigger types that can start a playbook — covers record-driven triggers (RecordCreate, RecordUpdate, RecordCreateOrUpdate), the time-based Scheduled trigger, all their inputs, and how parentRecord works when the trigger table differs from the playbook's parentTable. For the underlying wfa.playbook.trigger signature see playbook-api.
Unsupported Features
This document covers playbook features the Fluent SDK doesn't yet support. For each limitation you'll find what works, what doesn't, and what needs to be handled directly in Workflow Studio. Whenever a limitation applies, see Handling Unsupported Features at the bottom — it covers how to look up the playbook and provide a direct Workflow Studio link.
System Properties
Guide for creating ServiceNow System Properties using the Fluent API. Properties store key-value configuration for applications, read at runtime using gs.getProperty(), and allow admins to tune behavior without code changes.
Querying the Instance
now-sdk query runs a read-only Table REST API query against the authenticated ServiceNow instance. Use it for live, instance-specific data — column metadata, existing sys_ids, choice values, role memberships, scope info, etc.
Registering Events Guide
Guide for registering custom ServiceNow events in the Event Registry (sysevent_register) using the Record API, including custom queue configuration for high-volume event processing. Use when a custom event name is referenced, when building event-driven applications, or when the user mentions event registry, custom events, gs.eventQueue(), or custom queues.
Relationships and Related Lists
Guide for creating ServiceNow relationships and related lists using the Record API. Related lists display child or associated records on a parent form — for example, showing incident tasks on an incident form.
REST Message Guide
Guide for creating ServiceNow Outbound REST Messages (sysrestmessage) to call external HTTP services using the Fluent SDK. REST Messages define reusable, authenticated integrations with one base URL, shared headers, and multiple named HTTP operations callable from server-side scripts via sn_ws.RESTMessageV2.
Retry Policies
Guide for creating ServiceNow Retry Policies using the Fluent API. Retry policies control how outbound integration connections recover from transient failures by defining when to retry, how many times, and how long to wait between attempts.
Scheduled Script Guide
Create ServiceNow Scheduled Script Executions (sysauto_script) to run server-side logic on a time-based schedule. This guide covers all 11 frequency types, script file patterns, timezone handling, conditional execution, business calendar integration, and best practices.
Script Includes
Guide for creating ServiceNow Script Includes using the Fluent API. Script includes bundle reusable server-side logic into classes or utilities that can be called from business rules, scheduled scripts, other script includes, and client-side code via GlideAjax.
Scripted REST APIs
Guide for creating ServiceNow Scripted REST APIs using the Fluent API. Scripted REST APIs define custom web service endpoints for external integrations, with support for versioning, parameters, headers, and ACL-based security.
SDLC on ServiceNow
End-to-end SDLC guide for building, testing, and releasing ServiceNow apps using the ServiceNow SDK, Git, ReleaseOps, and CI/CD pipelines.
Implementing Security Guide
Implement ServiceNow application security using ACLs (syssecurityacl), Roles (sysuserrole), Security Attributes (syssecurityattribute), and Security Data Filters (syssecuritydata_filter). This guide covers the layered security model -- from defining roles, to creating ACL rules, to row-level filtering with data filters and reusable security predicates.
Catalog Client Scripts
Guide for building ServiceNow Catalog Client Scripts (catalogscriptclient) for service catalog items, record producers, and variable sets. These client-side scripts run in response to catalog form events such as onLoad, onChange, or onSubmit, enabling dynamic form behavior like field validation, visibility toggling, auto-populating fields from the current user, and user feedback messages.
Service Catalog
Guide for building ServiceNow Service Catalog components using the Fluent API — catalog items [sccatitem], record producers [sccatitemproducer], variables [itemoptionnew], variable sets [itemoptionnewset], UI policies [cataloguipolicy], and client scripts [catalogscriptclient]. Whenever the requirement is a form that captures user input and creates a record in a table — e.g., problem, incident, change_request, or a custom table, including mapping mandatory fields, applying validation, and confirming submission — the correct metadata is a Record Producer (CatalogItemRecordProducer), NOT a UI Page or a Scripted REST API. A Record Producer provides the form, field mapping (mapToField), validation (catalog UI policies + client scripts), and built-in submit/confirm behavior with no custom page or endpoint. Use a catalog item instead when ordering goods/services with approvals and fulfillment. Also use this guide when the user mentions service catalog, catalog items, record producers, variables, variable sets, UI policies, client scripts, form validation, dynamic fields, onChange, onLoad, onSubmit, ordering, or self-service. Includes property references, code examples, field mapping, scripting patterns, and best practices for end-to-end Service Catalog configuration. Only supported in SDK 4.3.0 or higher
Catalog UI Policies
Guide for building ServiceNow Catalog UI Policies (cataloguipolicy) — conditionally shows, hides, or sets variables on a catalog item, record producer or variable set based on a condition.
Service Catalog Variables
Servicenow guide to create Service Catalog Variables and Variable Sets. Creates a Variable(itemoptionnew) - single variable and Variable Set(itemoptionnew_set) - reusable collection of variables that can
Service Portal Fluent Advanced Guide
Advanced topics for Service Portal Fluent SDK: page route maps, widgetParameters serialization, platform constraints, OOTB widget and page references, scoped app restrictions, and troubleshooting. Every statement here is verified against the actual running example application.
Service Portal Fluent Components Guide
Reference for SPTheme, SPHeaderFooter, SPMenu, SPAngularProvider, and SPWidgetDependency. These are the supporting components that surround a widget — they control visual identity, navigation, shared AngularJS logic, and external library loading. All five map to distinct ServiceNow tables. You MUST check for reusable OOTB records before creating custom ones.
Service Portal
Guide for building ServiceNow Service Portal experiences using the Fluent API. Service Portal is a portal framework for building user-facing self-service experiences using AngularJS and Bootstrap 3. This guide covers core portal concepts: portals, pages, widgets, and themes.
Service Portal OOTB Reference (Gold Standard)
This file contains reference OOTB patterns from ServiceNow's global scope records, useful as a gold-standard starting point when creating custom headers, footers, or themes.
State Models
Guide for creating ServiceNow State Models using the Fluent API. A State Model defines the states a record can be in, the valid transitions between them, and the conditions that gate each transition — for example, blocking a Change from "Assess" to "Authorize" until an approval condition is met. A single StateModel() call creates the model record plus all of its state, transition, and condition records.
Adding Columns to an Out-of-Scope Table
Guide for adding custom columns to a platform or cross-scope table using augments. Use this when your application needs to attach fields to a table defined in another scope.
Tables, Columns, Column Overrides, and Relationships Guide
Guide for creating ServiceNow Tables (sysdbobject), Columns (sysdictionary), Column Overrides (sysdictionaryoverride), and Relationships (sysrelationship) to define data models. Use when the user mentions tables, columns, column overrides, fields, schema, extending tables, relationships, related lists, or data modeling.
UI Actions
Guide for creating ServiceNow UI Actions using the Fluent API. UI Actions are buttons, links, or context menu items that execute server-side or client-side logic on forms and lists.
UI Pages
Guide for creating ServiceNow UI Pages using React and the Fluent DSL. UI Pages are custom React-based interfaces for building forms, dashboards, list views, multi-step wizards, and any custom web experience within ServiceNow. They use React 18.2.0, the @servicenow/react-components library, Table API integration, CSS styling, and SPA routing via URLSearchParams.
UI Page Patterns
Development patterns and guidelines for ServiceNow UI Pages, covering dirty state management, field extraction, service layer architecture, CSS styling, build constraints, and file organization.
UI Page Theming
Horizon Design System theming reference for ServiceNow UI Pages, covering design foundations, layout patterns, controls, and component styling.
UI Policies
Guide for creating ServiceNow UI Policies using the Fluent API. UI Policies dynamically change form field properties (visibility, mandatory, read-only, cleared) and control related list visibility based on conditions evaluated when the form loads or field values change.
UserCriteria Examples Guide
This guide provides comprehensive, scenario-based examples for working with User Criteria in Fluent. For basic API usage and field definitions, see the usercriteria-api topic. For common mistakes and troubleshooting, see the user-criteria-guide topic.
User Criteria
User Criteria (user_criteria) are named, reusable access conditions that determine which users can view catalog items, knowledge articles, service portal topics, and other platform content. Required for controlling Service Catalog item visibility—always use instead of ACLs or the roles property for who can see/order catalog items. Unlike ACLs—which control read/write/delete operations on database records—User Criteria define audience membership based on combinations of users, groups, roles, departments, locations, companies, and optional scripts.
Views
Guide for creating ServiceNow UI Views using the Record API. Views define custom layout variants for forms and lists, controlling which fields/columns are shown and who can access the layout.
View Rules
Guide for creating ServiceNow View Rules using the Record API. View rules automatically switch users to a specific view based on conditions, device type, or custom scripts — unlike manual view selection from the dropdown.
Workflow Automation Custom Action Guide
Guide for creating and invoking reusable custom actions using the Fluent SDK. Custom actions encapsulate a sequence of OOB steps with typed inputs and outputs, and are invoked from any Flow or Subflow via wfa.action().
Workflow Automation Flow Actions Guide
Action types, flow logic, and patterns for ServiceNow WFA flows. Covers record operations, communication actions, approvals, tasks, attachments, control flow, and complete flow patterns.
Workflow Automation Flow Guide
Comprehensive guide for creating and editing ServiceNow Workflow Automation (WFA) flows using the Fluent SDK. Covers Flow Designer flows including triggers, actions, flow logic, data pills, approvals, and service catalog integration. Use this when implementing event-driven automation, scheduled tasks, approval workflows, or any WFA component.
Workflow Automation Flow Logic Guide
Flow logic constructs control how a flow executes -- branching, looping, and termination. They are invoked from inside a flow or subflow body via wfa.flowLogic.*.
Flow Stages Guide
Comprehensive guide for declaring and activating flow stages in ServiceNow workflows. Stages track progress of a Flow execution through named phases (e.g. Triage → Approval → Investigation). Two steps are needed: declare stages in the flow config header using FlowStage(), then activate them in the flow body using wfa.stage().
Workflow Automation Subflow Guide
Guide for creating and invoking reusable Subflows using the Fluent SDK. Subflows encapsulate flow logic with typed inputs and outputs, and can be invoked from any Flow or another Subflow via wfa.subflow().
Workflow Automation Trigger Guide
Triggers define when a Workflow Automation flow activates. They are the first argument to wfa.trigger() and fall into three categories: