Integrations

ServiceNow Puppet Integration Guide

advancedAPI Token Bearer AuthenticationPuppet Enterprise

ServiceNow Puppet Enterprise integration creates a unified infrastructure management workflow by connecting Puppet's configuration management capabilities with ServiceNow's IT service management processes. This integration solves the critical business problem of bridging the gap between infrastructure automation and ITSM governance, enabling organizations to maintain configuration compliance while ensuring proper change control and incident response. The integration is primarily used by DevOps teams, infrastructure engineers, and IT service management professionals who need visibility into Puppet-managed infrastructure within ServiceNow workflows. The integration supports bi-directional data flows including Puppet node inventory synchronization to the CMDB, automatic incident creation from Puppet report failures, and triggering Puppet tasks from ServiceNow change requests via REST API calls. The primary automation patterns involve scheduled imports for inventory data, webhook-based real-time incident creation from Puppet reports, and on-demand task execution triggered by workflow activities. The integration leverages ServiceNow's Integration Hub platform with custom REST Message configurations and CMDB import transforms.

Prerequisites

  • ServiceNow Tokyo release or later with Integration Hub Professional license
  • Puppet Enterprise 2021.7 or later with API access enabled
  • MID Server installed with network connectivity to Puppet Enterprise console
  • admin or itil role in ServiceNow for CMDB and incident management
  • Puppet Enterprise admin access for API key generation and webhook configuration
  • SSL certificates properly configured between ServiceNow MID Server and Puppet Enterprise console
  • Transform Maps application access for CMDB data mapping configuration

Architecture Overview

The integration uses ServiceNow's Integration Hub platform with custom REST Message records and Scheduled Script Executions rather than a dedicated spoke, as no official Puppet Enterprise spoke exists in the ServiceNow Store. Authentication is established using Puppet Enterprise API tokens stored in ServiceNow Connection & Credential Alias records, with credentials encrypted using ServiceNow's credential management system. Data flows bi-directionally with scheduled pulls for node inventory synchronization to the CMDB, webhook pushes from Puppet for real-time incident creation, and on-demand REST calls from ServiceNow to trigger Puppet tasks during change request workflows. A MID Server is required for outbound API calls to Puppet Enterprise console due to network security requirements and to handle SSL certificate validation for enterprise environments. The Puppet Enterprise API has rate limiting of 100 requests per minute per API key, requiring careful orchestration of bulk operations and appropriate error handling in ServiceNow integration scripts.

Sourdough
Chrome Extension

Sourdough: ServiceNow Monitoring and Analytics

A Chrome extension for ServiceNow Admins and Developers with essential tools, analytics, graphs and monitoring features.

Instance HealthGraphs & ChartsAPI HealthDeveloper ToolsQuick SearchInstance Switcher
Add to Chrome

Free to install. Pro $5/month after a 14-day no-card trial.
Pro requires the ServiceNow admin role. Upgrade inside the extension.

Overview
Tasks
CMDB
API
Metrics
Monitor
Internals
Instance:sourdoughdev·Version:Yokohama
Instance StateONLINE
System StatusFully Operational
Session Timeout90 minutes
Logged-In Sessions2 (20 active)
Build Nameyokohama-12-18-2024_p1
IP Address10.159.128.43
Instance HealthHealth Score: 90%
🔥 5dSourdough (Chrome Plugin)Dark Mode

Implementation Steps

1

Generate Puppet Enterprise API token and create ServiceNow credential

Log into your Puppet Enterprise console and navigate to User Preferences > Generate Token to create a new API token with appropriate permissions for node querying and task execution. Copy the generated token value immediately as it cannot be retrieved later. In ServiceNow, navigate to Connections & Credentials > Credentials and click New to create a new Basic Authentication credential. Set the Name field to 'Puppet Enterprise API', leave User name blank, and paste the API token into the Password field. This credential will be referenced by Connection Aliases for secure API authentication.

2

Create Connection Alias for Puppet Enterprise API endpoint

Navigate to Connections & Credentials > Connection & Credential Aliases and create a new alias named 'Puppet Enterprise Connection'. Set the Connection URL to your Puppet Enterprise console URL (e.g., https://puppet.company.com:4433). Select the credential created in step 1 from the Credential dropdown. In the Connection timeout field, set 30000 milliseconds to accommodate potentially slow API responses. Verify the connection by using the Test Connection functionality to ensure ServiceNow can reach your Puppet Enterprise console through the MID Server.

3

Configure REST Message for Puppet Enterprise API integration

Navigate to System Web Services > Outbound > REST Messages and create a new REST Message named 'Puppet Enterprise API'. Set the Endpoint to reference your Connection Alias using the syntax '${puppet_enterprise_connection}' where puppet_enterprise_connection matches your alias name. Configure the Authentication tab to use the Connection Alias created in step 2. Create HTTP Methods for common operations: GET method named 'get_nodes' with endpoint '/pdb/query/v4/nodes', GET method named 'get_reports' with endpoint '/pdb/query/v4/reports', and POST method named 'run_task' with endpoint '/orchestrator/v1/command/task'. Set appropriate HTTP headers including 'Content-Type: application/json' and 'Accept: application/json' for all methods.

ServiceNow Script
var rm = new sn_ws.RESTMessageV2('Puppet Enterprise API', 'get_nodes');
rm.setStringParameterNoEscape('query', 'query=["=", "certname", "web01.company.com"]');
rm.setMIDServer('YOUR_MID_SERVER_NAME');
var response = rm.execute();
var responseBody = response.getBody();
var httpStatus = response.getStatusCode();
4

Create CMDB Transform Map for Puppet node inventory synchronization

Navigate to System Import Sets > Administration > Transform Maps and create a new transform map named 'Puppet Nodes to CMDB'. Set the Source table to a new import set table called 'u_puppet_nodes_import' and Target table to 'cmdb_ci_server' or appropriate CI class. Create field mappings for essential attributes: map 'certname' to 'name', 'catalog_timestamp' to 'last_discovered', and 'facts.operatingsystem' to 'os'. Configure the coalesce field to 'name' to prevent duplicate CI creation. Add transform scripts to handle data type conversions and set appropriate CI class based on Puppet facts. Test the transform map with sample data to ensure proper CI creation and updates.

ServiceNow Script
// Transform script example for setting CI class based on OS
(function transformEntry(source, map, log, target) {
    var os = source.u_operating_system.toString().toLowerCase();
    if (os.indexOf('windows') >= 0) {
        target.sys_class_name = 'cmdb_ci_win_server';
    } else if (os.indexOf('linux') >= 0) {
        target.sys_class_name = 'cmdb_ci_linux_server';
    } else {
        target.sys_class_name = 'cmdb_ci_server';
    }
})(source, map, log, target);
5

Build scheduled job for Puppet node inventory import

Navigate to System Definition > Scheduled Jobs and create a new scheduled script execution named 'Puppet Node Inventory Sync'. Set the schedule to run daily at off-peak hours to minimize performance impact. In the script field, implement logic to query Puppet PuppetDB for node inventory, populate the import set table created in step 4, and trigger the transform map. Include error handling to capture API failures and notification logic for administrators. Add logging statements using gs.info() to track sync progress and record counts. Configure the job to run on a specific MID Server that has connectivity to your Puppet Enterprise console.

ServiceNow Script
var rm = new sn_ws.RESTMessageV2('Puppet Enterprise API', 'get_nodes');
rm.setMIDServer('YOUR_MID_SERVER_NAME');
var response = rm.execute();
if (response.getStatusCode() == 200) {
    var nodes = JSON.parse(response.getBody());
    var importGR = new GlideRecord('u_puppet_nodes_import');
    for (var i = 0; i < nodes.length; i++) {
        importGR.initialize();
        importGR.u_certname = nodes[i].certname;
        importGR.u_catalog_timestamp = nodes[i].catalog_timestamp;
        importGR.u_operating_system = nodes[i].facts ? nodes[i].facts.operatingsystem : '';
        importGR.insert();
    }
    var transform = new GlideTransformMap('Puppet Nodes to CMDB');
    transform.execute();
    gs.info('Puppet inventory sync completed: ' + nodes.length + ' nodes processed');
}
6

Configure inbound webhook for Puppet report processing

Navigate to System Web Services > Inbound > Scripted REST APIs and create a new API named 'Puppet Report Webhook'. Create a POST resource named 'process_report' with the path '/puppet/reports'. In the script section, implement logic to parse incoming Puppet report JSON, extract failure information, and create incidents for failed runs. Configure the webhook to validate report signatures if your Puppet setup includes webhook authentication. Set up proper error responses and logging for troubleshooting webhook delivery issues. Document the complete webhook URL format that will be configured in Puppet Enterprise, including the instance URL and API path.

ServiceNow Script
(function process(/*RESTAPIRequest*/ request, /*RESTAPIResponse*/ response) {
    var requestBody = request.body.data;
    var report = JSON.parse(requestBody);
    
    if (report.status === 'failed' || report.status === 'changed') {
        var incident = new GlideRecord('incident');
        incident.initialize();
        incident.short_description = 'Puppet run ' + report.status + ' on ' + report.certname;
        incident.description = 'Puppet report details: ' + JSON.stringify(report, null, 2);
        incident.caller_id.setDisplayValue('Puppet Automation');
        incident.category = 'Software';
        incident.subcategory = 'Configuration Management';
        incident.priority = report.status === 'failed' ? 2 : 4;
        var sysId = incident.insert();
        response.setStatus(201);
        response.setBody({status: 'success', incident: sysId});
    }
})(request, response);
7

Create Business Rule for triggering Puppet tasks from Change Requests

Navigate to System Definition > Business Rules and create a new async business rule named 'Trigger Puppet Task from Change'. Set the table to 'change_request' and condition to trigger when state changes to 'Implement'. In the Advanced tab, write a script that extracts target servers from the change request's affected CIs, constructs a Puppet task execution payload, and calls the Puppet Enterprise orchestrator API. Include proper error handling to update the change request with task results or failure messages. Add logic to parse task execution responses and create work notes documenting the automation results. Consider adding approval checks to ensure only authorized changes can trigger Puppet tasks automatically.

ServiceNow Script
(function executeRule(current, previous /*null when async*/) {
    var affectedCIs = current.cmdb_ci.getDisplayValue().split(',');
    
    for (var i = 0; i < affectedCIs.length; i++) {
        var rm = new sn_ws.RESTMessageV2('Puppet Enterprise API', 'run_task');
        var payload = {
            environment: 'production',
            task: 'service::restart',
            params: {service: 'apache2'},
            scope: {nodes: [affectedCIs[i].trim()]}
        };
        rm.setRequestBody(JSON.stringify(payload));
        rm.setMIDServer('YOUR_MID_SERVER_NAME');
        
        var response = rm.execute();
        var workNote = 'Puppet task execution on ' + affectedCIs[i] + ': ' + response.getStatusCode();
        if (response.getStatusCode() == 202) {
            var jobResult = JSON.parse(response.getBody());
            workNote += ' - Job ID: ' + jobResult.job.id;
        }
        current.work_notes = workNote;
        current.update();
    }
})(current, previous);
8

Test end-to-end integration and configure monitoring

Perform comprehensive testing by manually running the scheduled job to verify node inventory synchronization, sending test webhook payloads to validate incident creation, and creating a test change request to confirm Puppet task execution. Monitor System Logs > System Log > All for any integration errors and check Outbound HTTP Logs for API call success rates. Create a dashboard in ServiceNow to track integration health metrics including successful API calls, failed authentications, and processing times. Set up email notifications for integration failures by configuring notification rules that trigger when REST Message calls return error status codes. Document all integration endpoints, credentials, and troubleshooting procedures for operational support teams.

ServiceNow Script
// Health check script for integration monitoring
var healthCheck = {
    puppet_api_status: 'unknown',
    last_sync_time: null,
    active_incidents: 0
};

var rm = new sn_ws.RESTMessageV2('Puppet Enterprise API', 'get_nodes');
rm.setStringParameterNoEscape('limit', '1');
var response = rm.execute();
healthCheck.puppet_api_status = response.getStatusCode() == 200 ? 'healthy' : 'error';

var syncGR = new GlideRecord('sys_execution_tracker');
syncGR.addQuery('name', 'Puppet Node Inventory Sync');
syncGR.orderByDesc('sys_created_on');
syncGR.setLimit(1);
if (syncGR.next()) {
    healthCheck.last_sync_time = syncGR.sys_created_on.toString();
}

gs.info('Puppet integration health: ' + JSON.stringify(healthCheck));

Common Use Cases

Automated CMDB population from Puppet node inventory

ServiceNow automatically discovers and maintains configuration items in the CMDB based on Puppet node inventory and facts. The scheduled integration pulls node data including hostname, operating system, installed packages, and hardware specifications from PuppetDB and creates or updates corresponding CIs in ServiceNow. This eliminates manual CMDB maintenance and ensures infrastructure visibility for service mapping and impact analysis. The integration provides accurate asset inventory for ITAM processes and enables automated dependency mapping between applications and underlying infrastructure.

Incident creation from Puppet catalog compilation failures

When Puppet agents fail to compile catalogs or encounter errors during configuration enforcement, the integration automatically creates incidents in ServiceNow with detailed error information and affected node details. Webhook payloads from Puppet Enterprise include stack traces, resource failures, and environmental context that populate incident descriptions for faster troubleshooting. Priority levels are automatically assigned based on failure severity and node criticality defined in the CMDB. This ensures rapid response to configuration drift and compliance violations across the infrastructure.

Change request automation with Puppet task execution

Standard change requests in ServiceNow automatically trigger corresponding Puppet tasks or bolt plans when approved and moved to implementation phase. The integration maps change categories to specific Puppet automation workflows such as service restarts, package updates, or configuration deployments. Change implementers receive real-time feedback on task execution status and results through work notes populated by the integration. This approach ensures change control compliance while leveraging infrastructure automation for consistent and auditable implementations.

Security compliance reporting and remediation

ServiceNow integrates with Puppet's compliance reporting to track security policy violations and automatically initiate remediation workflows. Puppet compliance scans generate reports that create governance risk and compliance (GRC) policy exceptions in ServiceNow with detailed findings and affected systems. The integration can automatically assign remediation tasks to appropriate teams based on CMDB ownership and trigger Puppet remediation profiles to address common security findings. This creates a closed-loop security management process with full audit trails and automated compliance restoration.

Infrastructure service impact analysis and alerting

When Puppet reports indicate service disruptions or resource failures on critical infrastructure nodes, the integration correlates these events with business services defined in ServiceNow's service mapping. The system automatically identifies impacted business services and creates major incident records with proper escalation and notification workflows. Integration logic queries the CMDB to determine service dependencies and stakeholder notification lists based on CI relationships. This enables proactive incident management and reduces mean time to resolution by providing context-aware alerting with infrastructure root cause analysis.

Troubleshooting

REST Message calls return 401 Unauthorized errors when accessing Puppet Enterprise API

First verify that the API token stored in the ServiceNow credential is still valid by testing it directly against the Puppet Enterprise console API using a tool like curl. Check the Connection & Credential Alias configuration to ensure the credential is properly linked and the authentication type is set correctly. Navigate to Outbound HTTP Logs to examine the exact headers being sent and verify that the Authorization header contains the Bearer token. If the token has expired, generate a new one in Puppet Enterprise and update the ServiceNow credential record with the new value.

Scheduled job for node inventory sync fails with SSL certificate verification errors

This typically occurs when the MID Server cannot validate the SSL certificate presented by the Puppet Enterprise console. Check the MID Server logs for detailed SSL error messages and verify that the Puppet Enterprise console certificate is trusted by the MID Server's Java truststore. If using self-signed certificates, import the Puppet Enterprise CA certificate into the MID Server truststore using keytool command. Alternatively, configure the REST Message to skip certificate validation for testing purposes, though this is not recommended for production environments. Ensure that intermediate certificates are properly installed and that the certificate chain is complete.

Webhook payloads from Puppet are received but no incidents are created in ServiceNow

Enable debug logging in the Scripted REST API resource and check the application logs for JavaScript errors or null reference exceptions during payload processing. Verify that the incoming webhook payload structure matches the expected JSON format by logging the raw request body and comparing it against your parsing logic. Common issues include missing required fields like caller_id causing insert failures, or JSON parsing errors due to malformed payloads. Test the webhook processing logic using ServiceNow's REST API Explorer with sample payloads to isolate parsing or database insertion issues.

Transform Map execution fails during CMDB import with field mapping errors

Review the transform map logs in System Import Sets > Administration > Import Log to identify specific field mapping failures or data type conversion errors. Check that source data from Puppet contains expected values and that target CMDB CI fields accept the data types being mapped. Verify that choice list values in ServiceNow match the values coming from Puppet facts, and add transform scripts to handle data normalization. Ensure that mandatory fields in the target CI class are populated by the transform map, and that coalesce fields contain unique values to prevent duplicate CI creation or update conflicts.

Puppet task execution from change requests times out or returns incomplete results

Increase the REST Message timeout values to accommodate long-running Puppet tasks that may take several minutes to complete across multiple nodes. Implement asynchronous processing by storing the Puppet orchestrator job ID from the initial API response and creating a separate polling mechanism to check job status. Monitor Puppet Enterprise orchestrator logs to verify that tasks are being received and queued properly, and check for node availability issues that might cause task execution delays. Consider breaking large-scale changes into smaller batches to avoid overwhelming the Puppet orchestrator and provide more granular progress feedback to change implementers.

Integration performance degrades with large node inventories causing scheduled job failures

Implement pagination in the node inventory sync by using PuppetDB query limits and offsets to process nodes in smaller batches rather than retrieving all nodes in a single API call. Add checkpoint logic to track sync progress and resume from the last successful batch in case of failures, preventing full restarts of lengthy sync operations. Optimize CMDB queries by adding database indexes on coalesce fields and limiting the scope of CI updates to only changed records. Consider running inventory sync during off-peak hours and adjust the MID Server memory allocation if processing large JSON payloads causes out-of-memory errors.

Pro Tips

  • Implement custom Puppet fact collection for ServiceNow-specific metadata like CI identification numbers or service ownership information to improve CMDB accuracy and reduce manual mapping requirements. This approach creates a feedback loop where ServiceNow data enriches Puppet node classification and targeting.
  • Configure webhook payload validation using HMAC signatures or API keys to prevent unauthorized incident creation from spoofed Puppet reports. Store validation secrets in ServiceNow encrypted credential records and implement signature verification in your Scripted REST API resources for enterprise security compliance.
  • Use ServiceNow's Flow Designer to create sophisticated Puppet integration workflows that include approval processes for high-risk tasks, multi-stage rollback procedures, and integration with ServiceNow's Event Management for correlation with monitoring alerts. This provides a no-code approach for complex automation orchestration.
  • Implement intelligent task batching by grouping Puppet operations based on CI relationships and maintenance windows defined in ServiceNow to minimize service disruption during automated changes. Query CMDB relationships to determine optimal execution order and timing for infrastructure modifications.
  • Create custom ServiceNow reports and dashboards that correlate Puppet automation success rates with change request outcomes and incident volumes to measure the business impact of infrastructure automation. Use these metrics to optimize Puppet task selection and identify opportunities for additional automation.
  • Configure ServiceNow's Import Set transformer to handle Puppet fact hierarchies and complex data structures by flattening nested JSON into multiple related CI records, enabling comprehensive infrastructure modeling including network interfaces, storage volumes, and installed software packages.

Known Limitations

  • Puppet Enterprise API rate limiting restricts integration throughput to 100 requests per minute per API token, requiring careful orchestration of bulk operations and potential implementation of request queuing mechanisms for large-scale deployments. This limitation particularly impacts real-time sync scenarios and may require multiple API tokens for high-volume environments.
  • ServiceNow's standard CMDB CI classes may not accommodate all Puppet fact data types and hierarchical structures, requiring custom CI class creation or data flattening that can result in information loss during inventory synchronization. Complex Puppet fact data like network interface arrays or package lists need additional transform logic to maintain data integrity.
  • The integration lacks native support for Puppet's Continuous Delivery for PE workflows and requires custom development to integrate with pipeline-based deployments, code promotion processes, and automated testing frameworks. This gap limits the integration's effectiveness in GitOps and infrastructure-as-code environments where deployment orchestration spans multiple tools.
  • Real-time webhook processing in ServiceNow may experience delays during high-volume Puppet runs across large infrastructures, potentially causing incident creation lag and impacting SLA compliance for critical system failures. ServiceNow's platform processing limits and database transaction overhead can create bottlenecks during peak automation periods.
  • MID Server dependency introduces additional infrastructure requirements and potential single points of failure that must be considered in disaster recovery planning and may require clustering or redundancy configurations for enterprise availability requirements. Network connectivity issues between MID Servers and Puppet Enterprise console can disrupt all integration functionality.

Frequently Asked Questions

Can ServiceNow trigger Puppet runs on specific nodes outside of scheduled maintenance windows?

Yes, ServiceNow can trigger on-demand Puppet runs using the Puppet Enterprise Orchestrator API through REST Message calls or Flow Designer actions. You can configure Business Rules or Flow workflows to initiate puppet agent runs on specific nodes based on incident resolution, change request implementation, or other ServiceNow events. The integration supports both immediate execution and scheduled runs, with the ability to pass environment-specific parameters and task arguments. However, consider implementing approval workflows for ad-hoc Puppet runs to maintain change control compliance and prevent unauthorized system modifications.

How does the integration handle Puppet node decommissioning and CI lifecycle management?

The integration can detect decommissioned Puppet nodes by comparing current PuppetDB inventory against existing CMDB CIs and automatically retiring CIs that no longer appear in Puppet reports for a configurable period. Implement a cleanup job that queries for CIs with outdated last_discovered timestamps and moves them to Retired state rather than deleting them to maintain historical data for audit purposes. You should configure retention policies based on your organization's asset lifecycle requirements and ensure that decommissioned CIs are properly removed from service maps and dependency relationships. Consider adding approval workflows for automated CI retirement to prevent accidental removal of temporarily offline systems.

What is the best approach for handling Puppet environment promotion through ServiceNow change management?

Create custom change request templates that map to Puppet environment promotion workflows, using ServiceNow's approval processes to gate code promotion from development through production environments. Configure the integration to trigger Puppet Code Manager deployments via API calls when change requests reach specific approval states, ensuring that infrastructure code changes follow the same governance as application deployments. Implement integration with version control webhooks to automatically create change requests when new Puppet code is merged, linking commits to change records for complete traceability. Use ServiceNow's Flow Designer to orchestrate multi-stage deployments with rollback capabilities and automated testing integration between environment promotions.

How can I customize incident priority assignment based on Puppet report severity and affected CI importance?

Enhance the webhook processing script to query CMDB CI records for business criticality and service tier information, then apply priority calculation logic that considers both Puppet error severity and business impact. Create custom choice lists or reference tables that map Puppet resource types and failure modes to ServiceNow priority levels, allowing for granular control over incident escalation. Implement integration with ServiceNow's Business Service Management to automatically determine service impact based on CI relationships and assign priority accordingly. You can also configure VIP CI designation in the CMDB to ensure that failures on critical infrastructure components always generate high-priority incidents regardless of the specific Puppet error type.

Is it possible to integrate Puppet Bolt task results with ServiceNow's Security Incident Response module?

Yes, you can extend the integration to create security incidents from Puppet Bolt compliance scans and vulnerability assessments by configuring specialized webhook endpoints that process security-specific report data. Create custom incident categories and workflows in ServiceNow's Security Incident Response application that handle security remediation tasks triggered by Puppet compliance failures. Implement integration with ServiceNow's Vulnerability Response to correlate Puppet security findings with known CVEs and create comprehensive remediation plans that include both manual and automated response actions. The integration can automatically assign security incidents to appropriate teams based on CMDB ownership and trigger Puppet security profiles for automated remediation of common compliance violations.

What options exist for bulk operations when syncing large Puppet environments with thousands of nodes?

Implement pagination strategies using PuppetDB query parameters to process node inventory in configurable batch sizes, typically 100-500 nodes per API call to balance performance with memory usage. Use ServiceNow's Import Set framework with batch processing capabilities to handle large data volumes efficiently and implement checkpoint logic to resume failed sync operations. Consider deploying multiple MID Servers with load balancing to distribute API calls across different servers and improve overall throughput while respecting Puppet Enterprise rate limits. Create monitoring dashboards to track sync performance metrics and implement alerting for batch processing failures, allowing you to optimize batch sizes and scheduling based on actual system performance in your environment.

How does the integration handle Puppet certificate management and node authentication issues?

The integration can monitor Puppet certificate expiration dates by querying PuppetDB for certificate information and automatically creating preventive maintenance tasks or incidents for nodes approaching certificate renewal deadlines. Configure webhook processing to detect certificate-related errors in Puppet reports and create specialized incident types with appropriate escalation procedures for certificate management teams. Implement integration with ServiceNow's Certificate Management application if available to track Puppet certificates alongside other organizational certificates and automate renewal workflows. You can also create automated reports that identify nodes with certificate issues and generate work orders for certificate regeneration or signing, ensuring proactive certificate lifecycle management within ServiceNow's ITSM processes.

Test Your Knowledge

Quick 3-question quiz — see how your ServiceNow skills stack up.

Question 1 of 3Performance

A list view on a table with millions of records is slow. Best fix?

Select an answer to continue