Troubleshooting practice 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.

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.

Allow all data sources to use the default 'Discovery' source string to simplify configuration.

Why it fails: Sharing one source string across all sources defeats data source precedence, since precedence ranks distinct source values and cannot arbitrate identical ones. It is tempting to reduce configuration effort, and would be correct only in a single-source environment where no precedence arbitration is needed.

Bypass the IRE for manual spreadsheet imports to allow unrestricted table updates.

Why it fails: Bypassing the IRE for spreadsheet imports skips identification and reconciliation, creating duplicate CIs and bypassing precedence rules that protect attributes. It is tempting to speed up bulk loading, and would be correct only for non-CMDB staging tables that never feed the CMDB.

The target table does not have any UI Policies defined on its form view.

Why it fails: UI Policies control form field behaviour in the ServiceNow interface and are irrelevant to IRE, which matches and reconciles CMDB payloads server-side regardless of form configuration. IRE errors arise from missing identification rules, unmatched CI classes or duplicate detection conflicts. UI Policies would matter when controlling field visibility for agents.

The import set table row count exceeds 1,000 records per batch.

Why it fails: IRE errors stem from malformed source data, duplicate coalesce values or missing mandatory fields, not batch size; import sets routinely process far larger volumes. The 1,000-record figure is tempting because batch sizing matters for performance tuning of transform runs, but it never triggers IRE reconciliation failures.

Modify Access Control Lists to hide duplicate CIs from users.

Why it fails: Hiding duplicates via ACLs conceals the symptom while the underlying identification and reconciliation failure persists and keeps creating records. It is tempting as a quick cosmetic fix, and would be correct when restricting visibility of sensitive records, not resolving data quality.

Increase the timeout limit on all REST Message records.

Why it fails: REST timeout limits govern how long the integration waits for a response, not how incoming payloads are matched to existing CIs, so duplicates remain. Raising timeouts is correct when calls fail or truncate before completing, not when reconciliation logic is faulty.

Delete all Discovery schedules and recreate them from scratch.

Why it fails: Recreating Discovery schedules discards configuration without correcting the identification rules or reconciliation behaviour that produced the duplicates. It is tempting as a clean-slate reset, and would be correct when schedules themselves are corrupted or misconfigured, not for duplicate CIs.

Restart all MID Servers across the enterprise network.

Why it fails: Restarting MID Servers does not alter payload identification logic, which runs on the instance against the RTE configuration, so the errors persist. It is tempting because MID Server restarts are a common first response to integration failures, and it would be correct when the MID Server itself is unreachable or its queue is stalled.

Modify the instance web server memory allocation via system properties.

Why it fails: Web server memory allocation affects general instance performance, not RTE payload identification, which depends on parsing and transform configuration. It is tempting because memory tuning is a familiar fix for processing failures, yet it would be correct only when the instance itself is resource-starved, not when identification errors appear in RTE logs.

The CMDB Query Builder cache expired during the scan.

Why it fails: Query Builder caches store saved query results for reuse; they do not govern Service Mapping traversal, which follows discovered traffic and pattern rules. It is tempting because cache issues cause stale data elsewhere, but a stopped traversal with visible traffic points to a missing pattern or credential, not cache expiry.

The cmdb_rel_ci table has exceeded maximum indexing thresholds.

Why it fails: Indexing thresholds on cmdb_rel_ci affect query performance, not map traversal logic. It is tempting because large relationship tables can slow discovery, but Service Mapping stops when a pattern cannot identify the next CI; index limits would degrade speed or queries, never halt topology expansion at a load balancer.

The CMDB Health Correctness rule flagged the load balancer as a duplicate.

Why it fails: CMDB Health Correctness rules flag duplicate or orphan CIs for data-quality remediation; they do not block Service Mapping traversal. It is tempting because duplicate detection touches the same CI records, but a duplicate flag leaves the map intact. Traversal halts when no pattern matches the backend servers.

Create a Business Rule to merge duplicate records after discovery runs.

Why it fails: A Business Rule runs after discovery has already attempted identification, so records with the shared MAC address would still be misidentified or merged incorrectly before any cleanup occurs. It tempts teams wanting automated deduplication, but the CI Class Manager's identifier entries are the correct mechanism for resolving ambiguous identification during discovery itself.

Change the discovery schedule interval to prevent overlapping scans.

Why it fails: Schedule intervals govern when discovery runs, not how payloads are matched to CIs, so overlapping scans are irrelevant to devices sharing a MAC address. It tempts administrators assuming timing causes the collision, but the CI Class Manager's identifier configuration must instead be adjusted to include an additional unique attribute for reconciliation.

Disable the MAC address attribute from the cmdb_ci table entirely.

Why it fails: Removing the MAC address attribute from cmdb_ci destroys the very identifier discovery relies on to reconcile devices, so identification would fail entirely rather than resolve shared-MAC collisions. It tempts administrators wanting to eliminate the conflicting field, but the CI Class Manager instead supports adding a secondary identifier such as serial number or name to disambiguate devices.