Ingest practice questions

Discovery schedules do not support ingesting IP addresses automatically.

Why it fails: Discovery ingests IP addresses automatically via the IRE, so schedule capability is not the fault; the logged IRE payload error indicates a related-item processing failure, such as a missing lookup or coalescence rule. It is tempting when IPs are absent, but schedules are unrelated to payload rejection.

The cmdb_ci_ip_address table requires manual creation of records due to security restrictions.

Why it fails: The cmdb_ci_ip_address table is populated automatically by Discovery and IRE; no security restriction forces manual creation. It is tempting when records are missing, but the payload processor error points to IRE related-item handling, not table-level access controls.

Data Source Precedence has marked IP addresses as read-only.

Why it fails: Data Source Precedence resolves conflicts between sources for the same CI, not read-only flags blocking IP creation; the IRE payload error concerns related-item processing. It is tempting as a data governance control, but precedence governs which source wins, not whether related records insert.

cmdb_health_result

Why it fails: cmdb_health_result stores CI health and compliance check outcomes, not source attribution. It is tempting because it is a CI-related CMDB table, but the Data Source Precedence framework relies on the cmdb_ci_datasource table, which records each source that has updated a CI's attributes.

sys_import_set_row

Why it fails: sys_import_set_row holds staged rows from an import set before transformation, and is transient rather than historical. It is tempting because import sets do carry source information, but the Data Source Precedence framework reads cmdb_ci_datasource, which persists the CI-to-source relationship across updates.

cmdb_rel_ci

Why it fails: cmdb_rel_ci stores relationships between CIs, such as depends-on or runs-on links, not source attribution. It is tempting because it is central to CMDB modelling, but Data Source Precedence queries cmdb_ci_datasource, which records which sources have updated a CI's attributes.

Use the Import Set Web Service table API directly.

Why it fails: Import Set Web Service tables bypass IRE identification and reconciliation, so duplicate CIs are created instead of matched. It tempts because import sets are the standard inbound data path, but within a Scripted REST resource the correct call is the IRE's IdentificationEngine API.

Instantiate a GlideRecord on `cmdb_ci` and call `.insert()` for each item in the JSON body.

Why it fails: Direct GlideRecord inserts bypass the Identification and Reconciliation Engine entirely, so no reconciliation, deduplication or identifier rules run and duplicate CIs proliferate. It is tempting because GlideRecord is the standard way to create records, and it would be correct for simple, non-CMDB tables where no identification logic is required.

Call `current.update()` after mapping the JSON properties to the request object.

Why it fails: `current.update()` writes to the request's own Scripted REST resource record, not to any CMDB table, so no CI is created or reconciled. It is tempting because update() is the familiar pattern for saving a record in server-side scripts, and it would be correct when modifying the current record within a business rule or UI action.

Set the Data Source Precedence for line cards to 'Delete on Sync'.

Why it fails: Data Source Precedence resolves conflicting attribute values between sources; it does not remove relationships when a line card vanishes from a payload. It would be the right setting when two discovery sources disagree on a CI's name or serial number. Relationship cleanup on sync is performed by the Identification and Reconciliation engine's related-CI reconciliation.

Write a scheduled job to delete all line cards every night before the integration runs.

Why it fails: A nightly bulk delete removes every line card regardless of whether it was physically removed, so surviving cards lose their relationships and are recreated each run. It is tempting because scheduled cleanup jobs are a recognised pattern for purging genuinely stale records, and would suit data with no authoritative source feeding it.

Enable 'Cascade Delete' on the cmdb_rel_ci dictionary entry.

Why it fails: Cascade delete on dictionary tables is a database-level feature and is not recommended or used for managing CMDB relationship lifecycles.

sys_data_source

Why it fails: The sys_data_source table holds import set data sources, which define how external files and feeds are pulled into ServiceNow, not discovery source definitions. It is tempting because both concern data ingestion, but discovery sources such as MID Server ranges and credentials are stored in the discovery_source table.

cmdb_rel_ci

Why it fails: cmdb_rel_ci stores relationship instances between configuration items, not discovery source definitions. It is tempting because discovery populates relationships, but the registered source records live in the discovery source table used to tag CIs with their origin.

cmdb_ci

Why it fails: cmdb_ci holds configuration item records themselves, not the registry of discovery sources. It is tempting since discovered CIs populate this table, yet the source definitions that label each CI's provenance sit in a separate discovery source table.

Discovery Schedule Properties

Why it fails: Discovery Schedule Properties control when and how discovery runs, not precedence between manual imports and discovered values. It tempts because discovery populates those network attributes, yet source precedence is enforced by data policies on the CI class, not by schedule configuration.

Data Policies on cmdb_ci

Why it fails: Data policies enforce mandatory and read-only conditions universally, regardless of the data source.

Import Set Transform Map Field Maps

Why it fails: Transform map field maps control how incoming import columns map to target fields during a single import; they cannot enforce precedence against discovery across sources. It tempts because spreadsheets arrive via import sets, but the restriction must persist beyond that transform, which data policies provide.

The number of active user sessions currently logged into the ServiceNow instance.

Why it fails: Active user sessions have no bearing on Data Source Precedence, which resolves conflicting attribute values from different discovery sources by ranked source order. Session counts affect licensing or performance, not attribute-level reconciliation. This distractor tempts because session load can influence scheduled jobs, but precedence is evaluated per attribute, independent of concurrent logins.

Whether the attribute being updated is included in the class's identification rule criteria.

Why it fails: Identification rule criteria determine whether CIs match and merge, not which data source wins an attribute conflict. It is tempting because identification and precedence both run during reconciliation, but precedence compares source rankings and update timestamps for the attribute itself.

Disable the maintenance window field mapping in the Discovery schedule properties.

Why it fails: Discovery schedule properties do not hold per-field mapping toggles; field-level control lives in the classifier or pattern, so this setting cannot be disabled there. It is tempting because schedules appear to govern Discovery behaviour, and would be correct when suppressing an entire discovery run or adjusting its timing.

Set the Discovery schedule to run before the custom script.

Why it fails: Reordering runs does not stop Discovery overwriting the attribute; the nightly run still writes after the script's last execution, and the script's 15-minute cadence would simply re-populate then lose it again. It is tempting as a sequencing fix, and would be correct if the conflict were a one-off race rather than a recurring overwrite.

Remove the maintenance window attribute from the cmdb_ci table dictionary.

Why it fails: Removing the attribute from the dictionary deletes the field and its stored values entirely, destroying the maintenance window data instead of protecting it. It is tempting as a way to stop Discovery touching the field, and would be correct only when retiring an obsolete attribute no longer required on any CI.

Configure a scheduled job to run a script that sets the 'install status' to 'Retired'.

Why it fails: While a scheduled job could update CI records, it is not the native mechanism provided by the Service Graph Connector for absence detection. This approach would require custom scripting and would not automatically tie to the connector's discovery cycle, making it less reliable and not the intended configuration for this feature.

Modify the IRE identification rule to ignore missing CIs.

Why it fails: Identification and Reconciliation Engine (IRE) rules determine how incoming data is matched to existing CIs; they do not control what happens when a CI is missing from a subsequent ingestion. Modifying IRE rules would not achieve absence detection and could disrupt identification processes, so this is not the correct setting.

Enable the 'Delete' operation in the connector's data mapping.

Why it fails: Enabling the 'Delete' operation would cause the connector to delete CIs from the CMDB when they are removed from the source, which is the opposite of marking them absent. The requirement is to retain the CI but flag it as no longer present, so this setting would lead to data loss and is incorrect for this scenario.

Use a Scheduled Data Import with a Transform Map that has 'Coalesce' enabled.

Why it fails: Coalesce in a Transform Map performs simple matching based on specified fields but does not invoke IRE. While it can prevent duplicates, it lacks the advanced reconciliation and identification capabilities of IRE, such as multi-attribute matching and source precedence. Therefore, this method does not meet the requirement of invoking IRE.

Create an Import Set with a Transform Map that uses the 'IRE' transform script.

Why it fails: Import Sets with Transform Maps do not automatically invoke IRE unless the target table is a CMDB table and the transform is configured to use IRE. However, there is no standard 'IRE' transform script; instead, you must use the Identification and Reconciliation Engine by setting the transform map to use IRE or by using the CMDBTransformUtil. Simply adding a script does not guarantee IRE invocation. Thus, this is not a recommended method.

Use the 'IdentificationEngine' JavaScript API directly in a business rule.

Why it fails: The IdentificationEngine JavaScript API can be called from server-side scripts, but using it in a business rule is not a standard ingestion method. Business rules typically run on record operations and could cause recursion or performance issues. For ingestion, it is better to use the provided APIs or Import Sets with IRE. Thus, this is not a recommended method for invoking IRE during ingestion.

Check the 'No-Delete' flag on the Discovery Schedule record.

Why it fails: The No-Delete flag only prevents record deletion, not attribute overwrites, so it cannot stop the nightly run replacing the Asset tag. It is tempting because it sounds like a protective control, and it would be correct when Discovery must be blocked from removing CIs entirely.

Disable the 'Asset tag' field mapping in the IRE payload processor script.

Why it fails: The IRE payload processor handles reconciliation and merging of incoming payloads, not the field-level precedence that decides whether a manually edited attribute survives. Disabling a mapping there would be right when a specific source attribute should never populate a field at all.

Set the cmdb_ci table to read-only for the Discovery integration user via ACLs.

Why it fails: Read-only ACLs block all writes from the integration user, including legitimate CI updates, rather than resolving the attribute precedence conflict. This would be correct when a service account must be prevented from modifying any records, such as a strictly read-only audit integration.

RestMessageV2.execute()

Why it fails: RestMessageV2.execute() only sends an outbound REST call and returns the raw response; it never invokes the Identification and Reconciliation Engine, so no deduplication occurs. It is tempting because IntegrationHub actions commonly use it for HTTP work, and it would be right for fetching data from a third-party API rather than writing CIs.

CMDBAPI.ingest()

Why it fails: CMDBAPI.ingest() is not a real ServiceNow API, so the script fails at runtime rather than passing payloads through IRE. The name is tempting because it sounds like a purpose-built ingestion endpoint, and such an API would be the right choice if ServiceNow actually exposed one for CMDB writes.

GlideRecord.insert()

Why it fails: GlideRecord.insert() writes directly to the CMDB table, bypassing the Identification and Reconciliation Engine entirely, so no deduplication or reconciliation runs. It is tempting because GlideRecord is the standard scripting approach for creating records, and it would be correct for inserting into non-CMDB tables where IRE processing is unwanted.

Set the coalesce field on the Transform Map to point to the datastore ID.

Why it fails: Coalescing on the datastore ID applies to the datastore's own transform map, not the VM map; setting it there cannot create the related child datastore records from nested objects. It tempts because coalesce prevents duplicate CIs, which is correct for the parent VM record itself.

Flatten the JSON payload in a Business Rule before it reaches the Import Set table.

Why it fails: Flattening in a Business Rule runs after the import set is populated, so nested datastore objects are already lost or malformed before transformation; RTE handles related child records through a related transform map or onBefore script. It tempts because flattening simplifies payloads, which works for single-table imports without child relationships.

Create two separate import set tables and link them using a standard GlideRecord script in a Transform Map.

Why it fails: RTE handles nested child objects natively through related transform maps or child dataset definitions, so splitting into two import set tables and scripting GlideRecord links bypasses that mechanism and duplicates reconciliation logic. Two tables suit genuinely independent, unrelated feeds, not parent-child payloads sharing one source.

Add a Business Rule on cmdb_ci that checks the sys_updated_by field and aborts updates from the third-party source.

Why it fails: Business Rules execute on record insert or update and cannot arbitrate between discovery sources; aborting third-party writes leaves stale values rather than letting Discovery win. Data Source Precedence rules rank sources per CI class and attribute, so Discovery outranks the third-party tool for Operational status. Business Rules suit validation logic, not source ranking.

Modify the Discovery schedule to run after the third-party integration job completes.

Why it fails: Scheduling Discovery after the third-party job does not stop that tool writing stale values; precedence rules, not timing, decide which source wins per attribute. Timing would suit avoiding concurrent load or duplicate CI creation, but the stale overwrite recurs on every integration run regardless of order.

Create an Access Control List (ACL) that restricts write access on the cmdb_ci_linux_server table for the third-party integration user.

Why it fails: An ACL only blocks writes; it cannot make Discovery's value win when both sources write. Data Source Precedence exists precisely to rank sources per attribute, so Discovery would override the third-party feed. ACLs suit restricting who may modify records, not arbitrating conflicting values.

Modify the coalesce setting on the Transform Map to use serial number.

Why it fails: Coalesce fields on the Transform Map drive whether an incoming row updates or inserts before IRE runs; IRE identification uses its own identifier entries and reconciliation rules, not the transform coalesce. It is tempting because coalesce handles duplicate imports, but it does not control IRE matching.

Enable 'Robust Transform Engine' on the data source properties.

Why it fails: Robust Transform Engine only changes how transform scripts execute; it does not supply the identifier matching the IRE needs. Identification and Reconciliation relies on configured identifier entries (such as serial number or name) to match incoming payloads to existing CIs, so it would be correct once those identifiers are defined.

Create a Data Source Precedence rule for the import set.

Why it fails: A Data Source Precedence rule only resolves conflicts when multiple data sources supply values for the same CI attribute; it does not supply the missing unique identifier the IRE needs to match incoming rows to existing records. It is tempting because precedence genuinely governs which source wins during reconciliation, but that applies once identification has already succeeded.

The Transform Map is missing mandatory field mappings.

Why it fails: Transform Maps govern import-set staging and field coercion, not IRE identification logic; the error originates when the payload lacks the attributes named in the CI class's identification rules. It is tempting because mapping gaps do cause import failures, but those surface as skipped or empty fields, not this message.

The target CI table has mandatory dictionary fields that are not populated by the form layout.

Why it fails: Dictionary mandatory flags constrain form and record saves, not IRE matching; identification requires the attributes listed in the class's identifier entries. It is tempting because missing mandatory fields do block inserts, but the IRE error concerns identifier attributes absent from the payload itself.

The Discovery source name is invalid.

Why it fails: An unrecognised discovery source affects precedence and reconciliation ownership, not identification matching; the error means the payload omitted attributes defined in the CI class's identification rules. It is tempting because invalid source names do cause reconciliation warnings, but those differ from this mandatory-attribute message.

In Robust Transform Engine (RTE) definitions, map the process table to the software installation table.

Why it fails: Robust Transform Engine handles CMDB data imports and reconciliation, not Service Mapping process classification. It cannot resolve a discovered process to its software installation during mapping. RTE would be the right choice when transforming external data feeds into CMDB tables, such as normalising discovery sources before they populate the CMDB.

In CI Class Manager, modify the Identification Rule for cmdb_ci_appl.

Why it fails: Process classification and mapping relationships are governed by the process identification rules configured in the Service Mapping application, not by the cmdb_ci_appl identification rule in CI Class Manager. The latter governs application CI uniqueness and reconciliation, so it would be the right place only for deduplicating application records.

In Data Source Precedence rules, set Discovery as the primary source for process tables.

Why it fails: Data Source Precedence governs which discovery source wins when the same CI is reported by multiple sources; it cannot classify an unrecognised process or create the process-to-software-installation relationship. It would be the right choice when reconciling duplicate records from ServiceNow Discovery and another source, not for defining identification rules.

Discovery Log Analyzer

Why it fails: Discovery Log Analyzer inspects discovery schedules and probe results, not identification rules or payload processing. It is tempting because it diagnoses discovery failures, and would be the right choice when probes fail to run or return incomplete data during horizontal discovery. Here the requirement is testing identification rules against simulated payloads, which the Identification and Reconciliation engine simulation utility handles.

Transform Map Simulator

Why it fails: The Transform Map Simulator tests transform maps and coalesce logic, not identification rules or payload processing; the Identification and Reconciliation engine's simulator is the correct utility. It is tempting because both tools simulate ingestion, but they operate at different stages of the CI lifecycle.

Service Mapping Workbench

Why it fails: Service Mapping Workbench builds and validates topology maps for service instances by discovering application dependencies, so it cannot execute identification rules against simulated payloads. It is tempting because it also visualises CI relationships, but it suits mapping a business service's infrastructure, not diagnosing IRE payload processing.

Modify the IRE Identification Rule to automatically ignore whitespace.

Why it fails: Identification rules compare attribute values during IRE processing; they cannot strip characters, so whitespace-padded serials still fail to match. It is tempting because identification rules govern CI matching, and would be correct for defining which attributes uniquely identify a CI.

Write a Client Script on the target cmdb_ci table to strip whitespace upon insert.

Why it fails: Client scripts execute in the browser, not during Import Set transformation, so ingested records bypass them entirely and reach the IRE uncleaned. It is tempting because client scripts commonly enforce field formatting, and would be correct for validating data entered manually through the platform UI.

Configure a Data Policy to reject records containing whitespace.

Why it fails: Data policies validate and can reject records, but rejection discards the printer CI instead of normalising the serial for matching. It is tempting because data policies enforce data quality, and would be correct when malformed records must be blocked rather than corrected.

The IRE maps discovery sources based on IP address ranges rather than the discovery source string.

Why it fails: The IRE does not map discovery sources by IP address ranges; it matches on the discovery source string itself, so differing casing and format can cause records to be treated as coming from separate sources. IP-range logic belongs to subnet-based identification, not source reconciliation.

The IRE automatically normalizes all discovery source strings to lowercase and strips special characters.

Why it fails: The IRE does not automatically lowercase or strip characters from discovery source strings; it matches them as stored, so inconsistent casing and formatting across jobs can prevent records reconciling to one source. Normalisation must be configured deliberately, for example via a data source precedence or transform.

Discovery source names only affect reporting and have no impact on IRE reconciliation behavior.

Why it fails: Discovery source names directly drive IRE reconciliation, determining which source's values win during merges, so they cannot be dismissed as reporting-only metadata. Treating them as reporting labels is tempting because they appear in dashboards, but precedence and reconciliation depend on the exact string.