Troubleshooting Scenario Questions

Disable relationship validation in CMDB properties.

Why it fails: Disabling relationship validation removes the check that rejected the invalid type string, so the payload still cannot resolve to a valid relationship type and no cmdb_rel_ci record is created. It is tempting because validation appears to be the blocker, and it would be correct only if the incoming type strings were already valid.

Create a Transform Map to map relationship types.

Why it fails: A Transform Map maps incoming payload fields to target table columns during import; it does not translate an invalid relationship type string into a valid one for IRE. It is tempting because transform maps handle inbound data shaping, so it would be correct if the failure were field-level mapping rather than relationship type resolution.

Modify the cmdb_rel_ci table dictionary to allow free-text relationship types.

Why it fails: Allowing free-text relationship types in the cmdb_rel_ci dictionary bypasses the relationship type model, so IRE still cannot match the string to a defined type and the record is not created. It is tempting because it appears to relax the constraint, and it would be correct only if custom types were genuinely required.

Discovery Log analyzer widget

Why it fails: The Discovery Log analyzer widget aggregates discovery run status, errors and timing; it does not expose the raw payload or intermediate pattern variables. It is tempting because it is the standard first stop for failed discoveries, and would be correct for identifying which discovery run failed and at which phase.

CMDB Query Builder execution trace

Why it fails: CMDB Query Builder builds and runs reports against CMDB tables; it does not capture pattern execution state, so it cannot expose the raw payload or intermediate variables. It is tempting because it queries CMDB data, and would be the right choice for validating which CIs and relationships a completed pattern actually wrote.

Dependency Views inspector console

Why it fails: Dependency Views inspector console visualises CI relationships on a service map, not pattern execution internals, so it cannot expose raw payloads or intermediate variables. It is tempting because it is the natural tool for validating discovered dependencies and troubleshooting map topology after discovery, which is a different diagnostic task from debugging pattern logic.

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.

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.

Data Dictionary cascade delete settings on the sys_dictionary table

Why it fails: Cascade delete on sys_dictionary governs deletion of dependent records when a parent is removed, not relationship reconciliation during discovery. Incorrect payload identification points to identification and reconciliation rules; cascade delete settings would be relevant when cleaning up orphaned child records.

CMDB Health dashboard completeness scorecards

Why it fails: Completeness scorecards only report CMDB data quality metrics; they never modify or delete relationship records. The disappearing relationships stem from identification and reconciliation processing, so scorecards are relevant when monitoring data health trends, not when diagnosing payload-driven relationship loss.

Discovery Schedule exclude rules

Why it fails: Exclude rules prevent CIs from being discovered at all, so affected servers would never appear rather than losing existing relationships. Incorrect payload identification occurs during reconciliation of discovered data; exclude rules would be the right control when specific subnets or devices must be kept out of discovery scope.

Disabling the cmdb_rel_ci table index generation

Why it fails: Disabling index generation on cmdb_rel_ci removes the database indexes that keep relationship queries performant, degrading CMDB health rather than maintaining it. It is tempting when troubleshooting slow relationship inserts, and would be correct only as a temporary diagnostic step, never as a relationship-integrity mechanism.

Manual SQL direct database updates on the cmdb_rel_ci table

Why it fails: Direct SQL writes bypass ServiceNow's relationship business rules, audit trail and CMDB integrity checks, corrupting cmdb_rel_ci data. It is tempting as a quick fix when the UI blocks a change, and would be correct only for vendor-directed data repair under a documented change, never routine maintenance.

Whether the target CI table has active client scripts blocking the relationship field.

Why it fails: Client scripts execute in the browser during form interaction, not during server-side integration inserts, so they cannot block relationship fields written by a custom integration. They are the right suspect when users report fields being cleared or made read-only while editing records manually.

Whether the Discovery status schedule is set to 'Quick Discovery'.

Why it fails: Quick Discovery is a Discovery schedule execution mode controlling probe depth and duration; it has no bearing on whether a custom integration writes relationship records. It would be relevant when troubleshooting Discovery performance or incomplete horizontal discovery, not integration payload mapping.

Run a quick discovery scan to automatically regenerate the manual application service relationships.

Why it fails: Discovery populates infrastructure CIs and their dependencies, but a Manual Application Service holds only hand-built relationships, so a scan cannot regenerate them. Discovery is the right tool when services are modelled dynamically from discovered CIs, not for rebuilding manually authored mappings.

Convert the manual Application Service into a Business Application record.

Why it fails: Converting the record changes its class, not its relationships; the deleted supporting CIs remain absent, so downstream impact still fails. Business Application records suit top-level business ownership modelling, whereas the stem needs the Application Service's manual infrastructure mappings rebuilt.

Delete the Business Application and recreate it as a Technical Service.

Why it fails: A Technical Service groups infrastructure, not the business-facing Application Service whose manual relationships were purged, so recreating it that way still leaves impact analysis blind. Technical Services suit infrastructure-centric mapping; the stem requires restoring the Application Service's own manual CIs.

Modify the transform map script to delete duplicate records after insertion.

Why it fails: Deleting duplicates after insertion leaves the IRE creating them each run and risks removing legitimate records. The custom identifier must be added to the identification rule so the IRE matches the existing CI. Post-insertion deletion would be correct only for cleaning historical duplicates already present.

Write a Business Rule on cmdb_rel_ci to merge records with matching names.

Why it fails: Business Rules on cmdb_rel_ci fire on relationship records, not CI inserts, so they cannot merge duplicate CIs created by the feed. It is tempting because Business Rules are the usual tool for enforcing logic on record writes, and would be correct for validating or transforming relationship rows as they are created.

Disable the Identification and Reconciliation Engine for external feeds.

Why it fails: Disabling the Identification and Reconciliation Engine stops all CI identification and reconciliation, leaving the custom identifier unmapped and duplicates unresolved. It is tempting when IRE appears to be the source of duplication, and would be correct only when feeds must bypass IRE entirely and be loaded as raw, unreconciled data.

Client-side form layout (UI policies)

Why it fails: UI policies control form field behavior, not graph visualization topology.

The local browser cache size of the end user

Why it fails: Browser cache does not dictate logical CI relationship rendering.

Discovery schedule polling intervals

Why it fails: Polling intervals control scan timing, not map rendering logic.

Modify the Transform Map coalesce script to loop through the array.

Why it fails: Transform Maps and coalesce scripts apply to import set staging tables, which run before IRE; they cannot restructure an already-built IRE payload. The nested array requires a relation or nested-payload mapping entry in the IRE payload mapping. Transform Maps tempt because they handle arrays during import, not during IRE processing.

Create a Business Rule to split the JSON array into individual rows on the import staging table.

Why it fails: Business Rules on staging tables execute during import set processing, before the payload reaches IRE, so they cannot split nested IRE objects. The interface array must be declared as a nested payload relationship in the IRE payload mapping. Staging-table rules tempt because they commonly flatten arrays during standard imports.

Add 'network_interfaces' as a comma-separated string column in the base cmdb_ci table dictionary.

Why it fails: Nested arrays require a relation mapping in the IRE payload, not a dictionary column on cmdb_ci. Adding a comma-separated string column stores the raw text but creates no interface CIs and no relationships. Dictionary columns suit scalar attributes on the parent record, not child CI extraction.

Data archiving automatically deletes relationship records older than 30 days.

Why it fails: ServiceNow does not automatically purge CMDB relationship records after 30 days; archiving targets task and audit data, not cmdb_rel_ci entries. It is tempting because archiving does remove aged records, and would be the cause if the missing data were historical task records rather than active dependency relationships.

The CMDB Query Builder cache needs to be manually cleared.

Why it fails: CMDB Query Builder results are computed at query time and cached per session; a stale cache would not remove database nodes from Dependency Views, which reads relationships directly. It is tempting because cache clearing is a common troubleshooting step, and would be correct if the query results themselves appeared outdated.

The cmdb_ci table has reached its maximum row count limit for relationships.

Why it fails: The cmdb_ci table has no maximum row count that silently drops relationships; missing nodes stem from absent or incorrect cmdb_rel_ci records, often due to discovery patterns or credentials. It is tempting because large CMDBs do hit performance limits, and would be relevant if the instance were genuinely throttled by table size.

Check the System Log (syslog) for standard warning messages tagged with 'TransformMap'.

Why it fails: TransformMap-tagged syslog warnings relate to import set transformation, not IRE payload rejection; IRE outcomes are logged in the CMDB IRE message/error tables. It is tempting as a general troubleshooting log, but it does not capture IRE coalescence or related-item failures.

Review the Email Notifications table for failed ingestion alerts.

Why it fails: Email notifications only fire if an alert rule is configured for ingestion failures; IRE rejections are recorded in the IRE log and CMDB error tables, not the notifications queue. It is tempting as a failure-alerting mechanism, but it is not where payload rejection detail resides.

Inspect the Discovery Status dashboard.

Why it fails: Discovery Status reports on Discovery schedules and probes, not IntegrationHub REST imports, so it holds no IRE rejection detail for this payload. It is tempting because Discovery also surfaces identification errors, and it would be the right place had the import been a horizontal Discovery run rather than a scheduled import set.

The Service Level Agreement (SLA) definition table for expired response times.

Why it fails: SLA definitions govern response and resolution timers on task records; they have no bearing on RTE transform execution or IRE insert failures. It is tempting because SLA breaches appear in platform health reporting, and it would be correct if the symptom were missed support targets rather than staging rows failing to reach the CMDB.

The UI Macro table for broken form decorators.

Why it fails: UI Macros render form decorators and widgets; they never participate in RTE processing or IRE insert logic, so a broken macro cannot block staging rows reaching the CMDB. It is tempting because form rendering faults are visible during testing, and it would be correct if the symptom were malformed forms rather than failed identification.

CI Class Manager

Why it fails: CI Class Manager administers the class hierarchy, identification rules and reconciliation settings; it configures how classes behave rather than displaying live dependency maps between individual CIs. It is tempting because class structure underpins relationships, and it would be correct for defining which classes may relate to which.

Discovery Schedule configuration

Why it fails: A Discovery Schedule sets when and against which IP ranges or credentials discovery runs; it controls data collection timing, not the traversal or graphical display of existing CI relationships. It is tempting because discovery populates the CMDB, and configuring a schedule would be correct to control how often discovery executes.

System Definition > Tables

Why it fails: System Definition > Tables is an administrative module for browsing table schemas and dictionary records, not a visualisation or investigation tool. It tempts administrators who already know their way around the platform, since it does expose CI class hierarchies and field definitions, but it renders no relationship graph.