Build on the Now Platform — from an Angular developer's starting point
The Now Platform, Glide scripting, ITSM & CMDB, Flow Designer, REST integrations and App Engine Studio — with a deliberate detour through Service Portal, where widgets are still built on AngularJS. If you already think in components, scope and data binding, this course spends real time showing you exactly where that maps and where it doesn't.
Prerequisites & tooling
What you should already know
- Comfortable with everyday JavaScript (ES6+) — Glide scripts and widget controllers are both plain JS
- Prior Angular (or AngularJS) experience is a real head start for the Service Portal modules, but isn't required
- Basic HTML/CSS and command-line comfort
- No prior ServiceNow, ITIL or admin background needed
Stack you'll work with
A free Personal Developer Instance (PDI) is all the infrastructure this course needs — no local install.
Your 26-week learning path
Twenty-five modules — platform fundamentals, server-side Glide scripting, Service Portal's AngularJS widgets, ITSM & integrations, then a scoped app you design, build and ship.
The Now Platform: Instances, Studio & Navigation
Get oriented before you write a single script — what you're actually working inside.
- Spinning up a free Personal Developer Instance (PDI)
- The platform's layers: tables, applications, scopes
- Navigating Studio, the classic UI and the application navigator
Data Model Deep Dive: Dictionary, Extended Tables & Relationships
Every table you'll ever touch inherits from three base tables — know that hierarchy cold.
- The
tasktable hierarchy and table extension - Dictionary entries, field types & reference fields
- Dot-walking, related lists & the
sys_id/GUID model
Forms, Lists, UI Policies & Client Scripts
The browser-side layer — the closest thing ServiceNow has to component-level logic.
- Form/list layout, sections & related lists
- UI Policies for declarative show/hide/mandatory logic
- Client Scripts:
onLoad,onChange,onSubmitand theg_formAPI
GlideRecord: Server-Side Data Access
The single API you'll use more than any other on this platform.
- Querying, encoded queries & the query builder
- CRUD with
insert(),update(),deleteRecord() - GlideAggregate & avoiding the classic "query in a loop" trap
Business Rules: Order, Types & Best Practices
Where most of ServiceNow's server-side automation actually lives.
- Before, after, async & display Business Rules
- Execution order & the
current/previousobjects - Avoiding recursive triggers & runaway rule chains
Script Includes: Reusable Server-Side Logic
The closest analogue to an Angular service — injectable, testable, on-demand server logic.
- Class-based Script Includes & prototype inheritance
- Callable-from-client vs. server-only Script Includes
- Extending
AbstractAjaxProcessor
Access Control: ACLs, Roles & the Security Model
How ServiceNow decides who can see and touch what — at the table, field and even row level.
- Table-level, field-level & row-level ACLs
- Roles, groups & ACL scripts with
gs.hasRole() - Debugging "why can't this user see this record"
GlideAjax: Calling the Server from the Client
The bridge between browser-side scripts and server-side logic — your first real client/server round trip.
- Synchronous vs. asynchronous
GlideAjaxcalls - Passing parameters & returning structured data (XML/JSON)
- Why this pattern is the direct ancestor of a widget's server call
Service Portal Architecture: Portals, Pages & Rows
The framework you came for — and where your Angular instincts start paying off.
- Portals, pages, rows, columns & containers
- Themes & the Service Portal Designer
- Why Service Portal still ships on AngularJS 1.5, and what that means for you
Widget Anatomy: HTML, CSS, Server Script & Client Controller
Every widget is four files acting like one component — learn to read them as one unit.
- The four widget files & how they relate
- The
data/inputobjects passed server → client - Building your first widget end to end
AngularJS in Widgets: Scope, Data Binding & the Digest Cycle
What c.data and $scope actually are — and how AngularJS 1.x change detection differs from what you know.
- The controller's
cobject as AngularJS's$scope - Two-way binding & the digest cycle vs. zone.js/signals
- Directives you already know:
ng-if,ng-repeat,ng-model
c.server.update(): Calling the Server from a Widget
The one call that quietly does everything GlideAjax did in Week 8, packaged cleanly.
- Round-tripping data with
c.server.update() - Loading & error states inside a widget
$sp.getWidget()for embedding a widget in server script
Widget Options & Dynamic Instantiation
Making a widget reusable across pages — the widget equivalent of @Input().
- Widget option schema & instance options
- Spawning widgets dynamically with
sp-widget - Building a configurable, reusable data-table widget
Widget Communication: $broadcast, $emit & Shared Services
Cross-widget messaging — AngularJS's answer to what you'd reach for a service or an EventEmitter for.
$rootScope.$broadcast/$emit/$on- Shared AngularJS services across widgets on a page
- When to reach for events vs. shared state
Catalog Client Scripts, UI Policies & Variable Sets
The Service Catalog is a form too — with its own client-side scripting model to learn.
- Catalog items, variables & variable sets
- Catalog Client Scripts & the
g_formAPI on portal forms - Building a request item (RITM) workflow end to end
ITSM Core: Incident, Problem & Change Management
Step back from code and learn the processes ServiceNow was actually built to run.
- Incident lifecycle, priority/impact/urgency
- Problem management & root cause records
- Change management, risk & approval workflows
CMDB & Discovery Fundamentals
The data model underneath every ITSM process — what a CI actually is.
- Configuration Items & the
cmdb_cihierarchy - Relationships & dependency views
- How Discovery populates the CMDB (conceptually)
Flow Designer & Integration Hub
Low-code automation — and when it should replace a Business Rule entirely.
- Flows, actions, triggers & subflows
- Flow Designer vs. Business Rules vs. Workflow Editor
- Integration Hub spokes for external actions
REST Integrations: Table API & Scripted REST APIs
Consuming ServiceNow from outside it, and exposing your own endpoints.
- The built-in Table API & authentication (OAuth, basic)
- Building a Scripted REST API resource
- Calling it from a widget's server script
Outbound Integrations, Import Sets & MID Server Basics
Getting data in and out of the platform at scale, not one record at a time.
- Outbound REST messages &
RESTMessageV2 - Import Sets & Transform Maps for bulk data
- What a MID Server is for, conceptually
Scoped Applications & App Engine Studio
Building your own application instead of customizing someone else's.
- Application scopes & cross-scope access
- Designing tables, relationships & roles in App Engine Studio
- Scaffolding the capstone app's data model
UI Builder & the Shift Beyond AngularJS
ServiceNow's newer, component-based page builder — and how it compares to what you just learned.
- UI Builder pages, components & data resources
- Client state, events & the client-script-per-component model
- Choosing UI Builder vs. Service Portal for a new project
Automated Test Framework (ATF) & Unit Testing Scripts
Prove your app works without clicking through it by hand every time.
- ATF tests, steps & test suites
- Server-side unit tests with
GlideRecordassertions - Running ATF tests as part of a pipeline
Update Sets, Source Control & ServiceNow DevOps
Move work between instances safely, and stop treating production as the only source of truth.
- Update Sets: capture, complete, retrieve, commit
- Git-based source control & the CI/CD app
- A promotion pipeline: dev → test → prod
Capstone: Ship a Scoped App with a Service Portal Frontend
Apply every module in one project — a real scoped application, tested and promoted through Update Sets.
- A custom scoped app: tables, ACLs, Business Rules & a Flow
- A Service Portal page built from your own widgets
- Portfolio-ready project you can demo to employers