Friday, November 20, 2026

Reading ServiceNow Plugin Logs: Proving an Upgrade Really Landed

Reading ServiceNow Plugin Logs: What Loading update Actually Means

You upgrade a ServiceNow store app. The release notes list ten fixes. The install log scrolls past a few thousand lines of Loading update: .... Everything looks fine.

Then, three weeks later, a user tells you something that was supposedly fixed is still broken.

This article is about closing that gap. It covers two things that turn out to be closely related: how to read plugin install logs without being misled, and how to prove, from instance data rather than from a changelog, that each fix in a release actually landed. The worked example is a real upgrade of GRC: Policy and Compliance Management (sn_compliance) to 23.0.2, but nothing here is GRC-specific. The techniques apply to any store app or plugin.

QuestionShort answer
Does a Loading update: line mean the record changed?No. It is written for every record in the payload on every install, whether or not anything differs. Most are no-ops
What is the best proof that a field-level fix landed?sys_audit, filtered to the install window. It is the upgrade's receipt
Which single list is actually actionable after an upgrade?Upgrade History → Skipped changes. That is where a delivered fix lost to a local customization
How do I decode an unfamiliar log filename?Never parse it by eye. Query sys_metadata on sys_update_name
Can every release note be verified from data?No. Some need a functional test and some cannot be verified from metadata at all. Recognising which is which saves hours

1. The Core Problem: Release Notes Are Claims, Not Evidence

A release note says "Fixed X." That tells you what the vendor changed in the payload. It does not tell you:

  • whether that change applied to your instance
  • whether it was skipped because a local customization collided with it
  • whether the fix lives in this app or in a dependency you did not upgrade
  • whether the fix is even observable as a record at all

Those are four different failure modes, and they need four different checks. So before touching anything, sort every item in the release notes into one of three buckets.

VerdictMeaningHow you confirm
Confirmed in dataA record changed, and you can point at the before and aftersys_audit
Needs functional testLogic changed; only behaviour proves itReproduce the original bug
Not verifiable via metadataPackaging-level or database-level changeStatic check or DB-layer inspection

Most teams only ever do the second bucket, and only for the fixes they happen to care about. The first bucket is nearly free and far more conclusive. The third is where people waste hours hunting for records that were never going to exist.

What to actually learn: triage first, test second. Every minute spent classifying a release note saves ten minutes of testing the wrong thing.

2. Establish the Version Baseline, Including Dependencies

Before validating anything, find out what you are actually running. Query sys_store_app:

sys_store_app.list -> scopeSTARTSWITHsn_

Pull scope, version, latest_version, active, update_available, dependencies and compatibilities. In the real example, this immediately reframed the whole exercise.

AppScopeInstalledLatest available
Policy and Compliance Managementsn_compliance23.0.223.0.2
GRC: Profilessn_grc23.0.723.1.2
GRC: Audit Managementsn_audit22.3.123.0.2
GRC: Operational Resiliencesn_oper_res22.3.223.0.9

Only part of the app family had moved. That matters enormously, because when I traced the individual fixes, several of the artifacts named in the sn_compliance release notes physically live in sn_grc: a shared script include, and a dictionary record on a shared base table.

What to actually learn: in a multi-app suite, a fix attributed to one app is routinely implemented in a sibling. Always baseline the whole family, and treat the dependencies field as part of your test plan.

Reading the compatibilities field

The compatibilities field is also worth reading. In this case sn_compliance 23.0.2 declared Australia;Brazil;Zurich;, which decoded two otherwise cryptic release-note phrases ("the Zurich release", "the Australia version"). Those were not localizations or regions. They were platform release families. A quick check of the glide.war system property confirmed which family the instance was on:

glide.war = glide-australia-02-11-2026__patch7-...

Half of what looks like gibberish in release notes is just release-train naming.

Record the install window now

While you are establishing the baseline, write down the install window: the timestamp of the first and last lines of the install log. Every later step (sys_audit, sys_updated_on comparisons) depends on it, and it is much easier to capture on the day than to reconstruct a month later. Remember that internal timestamps are stored in UTC, so note the timezone you read them in.

3. sys_audit Is the Upgrade's Receipt

This is the single highest-value technique in the article.

Store-app installs typically do not write sys_update_version or sys_update_xml records. Those are the mechanism behind update sets, which is why developers trained on update sets go looking for a diff after a store upgrade and come up empty.

But field-level changes to audited tables still land in sys_audit. So you can reconstruct what the upgrade touched:

sys_audit.list -> sys_created_onBETWEEN<install start>@<install end>
                  ^tablenameINsys_dictionary,sys_security_acl,
                              sys_security_acl_role,sys_script,sys_ui_policy

In the example, that query returned just five schema and security rows for the entire upgrade window. Five, out of thousands of Loading update: lines. And one of them was a bullseye.

FieldOld valueNew value
read_only10
read_only_optionclient_script_modifiable(empty)

That was the sys_dictionary record for sn_grc_indicator.next_run_time, label "Next run date." The release note claimed "Resolved 'Next run date' in IRM indicators being read-only." Here was the dictionary record being flipped from read-only to editable, timestamped inside the install window.

That fix went straight into the "confirmed" bucket. Validation dropped from "design a test plan" to "open a record and confirm the field is editable."

The bonus: undocumented changes

Two more rows in that same window showed reference_qual migrating from current.sys_class_name to current.getTableName(). That is a correctness fix for reference qualifiers evaluated on a base table from a child-table context. Nobody documented it in the release notes. sys_audit found it anyway.

The same query as a read-only script

If you prefer a script you can rerun and attach to a change record, this does the same job. Run it in a sub-production instance first, and adapt the timestamps (internal UTC format).

// Read-only: list schema/security changes written during the install window
var start = '2026-11-01 10:00:00';   // placeholder - install start (UTC)
var end   = '2026-11-01 11:30:00';   // placeholder - install end (UTC)

var gr = new GlideRecord('sys_audit');
gr.addQuery('tablename', 'IN',
  'sys_dictionary,sys_security_acl,sys_security_acl_role,sys_script,sys_ui_policy');
gr.addQuery('sys_created_on', '>=', start);
gr.addQuery('sys_created_on', '<=', end);
gr.orderBy('sys_created_on');
gr.query();

while (gr.next()) {
  gs.info(gr.getValue('tablename') + ' | ' + gr.getValue('documentkey') + ' | ' +
          gr.getValue('fieldname') + ' | ' + gr.getValue('oldvalue') + ' -> ' +
          gr.getValue('newvalue'));
}

What to actually learn: sys_audit, filtered to the install window, tells you what actually changed. Run it before you write a single test case. It will both confirm fixes and surface undocumented ones. One caveat: it only helps for tables that are audited on your instance, so confirm that before you read an empty result as "nothing changed."

4. Decoding "Loading update:" Lines

Now the logs. A line like this:

Loading update: sn_compliance/update/sys_dictionary_sn_grc_item_classification.xml

decomposes as:

sn_compliance / update / sys_dictionary_sn_grc_item_classification.xml
^^^^^^^^^^^^^   ^^^^^^   ^^^^^^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^
|               |        |              |           |
package         dir      record type    table       column
  • package: the app whose payload carries the record (not necessarily the app that owns it)
  • update/: the standard folder in every app package holding metadata records
  • record type: the table the record belongs to; here, sys_dictionary, a field definition
  • table + column: the target of that field definition

As section 6 explains, the table and column part is not always splittable by eye.

Why one app ships another app's fields

The first thing that confuses people: why is sn_compliance loading dictionary records for sn_grc_item columns?

Because sn_grc_item (label "Item", scope sn_grc, is_extendable = 1) is the shared GRC base table, and sn_compliance_control extends it directly.

         +--------------------------------------------+
         |  sn_compliance payload ships               |
         |  sys_dictionary records for the            |
         |  PARENT's columns                          |
         +--------------------------------------------+
                                |
                           applies to
                                v
      +----------------------------------------------------+
      |  sn_grc_item  --  "Item"                           |
      |  base table, scope sn_grc, extendable              |
      +----------------------------------------------------+
                                |
                             extends
                    +-----------+----------------------------+
                    |                                        |
                    v                                        v
  +----------------------------------+  +--------------------------------+
  |  sn_compliance_control           |  |  other GRC children            |
  |  "Control"                       |  |  (risk, audit, resilience)     |
  |  scope sn_compliance             |  |                                |
  +----------------------------------+  +--------------------------------+

A child app's payload carries definitions for the parent columns it depends on, to guarantee the inherited schema matches what it expects. In this case one of those columns, state, was actually owned by sn_compliance (its sys_package pointed at the Compliance scope), meaning Compliance contributes a column to the shared base table.

What to actually learn: cross-scope dictionary loads in a table-inheritance suite are normal. Do not chase them.

5. "Loading" Does Not Mean "Changed"

This is the misreading that matters most. A Loading update: line is emitted for every record in the payload on every install, whether or not the value differs from what is already in the database. Most are idempotent no-ops.

Here are six consecutive dictionary loads from the real log, checked against the instance.

Columnsys_updated_onsys_mod_countVerdict
classificationinstall window, by system1actually changed
respondents2023-09-050no-op
owner2021-05-120no-op
profile2020-07-090no-op
state2015-10-220no-op
number2015-10-140no-op

One of six did anything. sys_mod_count and sys_updated_on are your signal; the log line is just noise.

What a real problem looks like

For contrast, these are the log patterns worth reacting to:

  • Skipping update: ... or *** Skipped ***: a delivered record was not applied because a local customization collided with it
  • Could not load, Error loading update or Caused by:: genuine failure
  • Collision detected or Reverted to base system
  • Dropping column or Altering table warnings on large tables

A bare Loading update: with no qualifier is a clean application. Exact wording varies between releases, so treat the list as patterns to search for rather than a fixed vocabulary.

6. The Filename Trap (and a Correction)

I will own a mistake here, because it is instructive.

I initially described the convention as sys_dictionary_<table>_<element>. Then a filename like this came up:

sys_dictionary_grc_control_sn_policy_compliance_statement.xml

My rule cannot parse it. The separator is _, and both table names and column names contain _, so there is no recoverable boundary:

sys_dictionary_grc_control_sn_policy_compliance_statement
               |         | |                          |
               +----A----+ +------------A-------------+
               +--------B----------+ +-------B--------+
               +------------C-------------+ +---C----+

  A:  table  = grc_control
      column = sn_policy_compliance_statement

  B:  table  = grc_control_sn_policy
      column = compliance_statement

  C:  table  = grc_control_sn_policy_compliance
      column = statement

And this is not academic. Here is a real record on the instance:

AttributeValue
sys_update_namesys_dictionary_sn_compliance_m2m_statement_profile_type_sn_compliance_statement
Actual tablesn_compliance_m2m_statement_profile_type
Actual columnsn_compliance_statement

The column begins with the app's own scope prefix, exactly like a table name would. No eyeball parse survives that.

The fix: query, don't parse

sys_update_name is a real field on sys_metadata. Strip .xml, paste, and let the platform do the split:

sys_metadata.list -> sys_update_name=sys_dictionary_grc_control_sn_policy_compliance_statement

Because it lives on sys_metadata, this works for any metadata type without knowing which table to search. Use STARTSWITH to see siblings:

sys_metadata.list -> sys_update_nameSTARTSWITHsys_dictionary_grc_control

Worth knowing: sys_dictionary and sys_choice are the ambiguous ones. Most metadata types key on sys_id and parse trivially.

File patternKeyed byAmbiguous?
sys_dictionary_<table>_<column>.xmltable + columnyes
sys_choice_<table>_<column>_<value>.xmltable + column + valueyes
sys_db_object_<sys_id>.xmlsys_idno
sys_script_<sys_id>.xmlsys_idno
sys_security_acl_<sys_id>.xmlsys_idno
sys_ui_policy_<sys_id>.xmlsys_idno

Checking many log lines at once

If you have a shortlist of log lines to check, a small read-only script saves a lot of clicking. Paste the file names without .xml:

// Read-only: for each log line of interest, report what the instance holds
var names = [
  'sys_dictionary_sn_grc_item_classification',
  'sys_dictionary_grc_control_sn_policy_compliance_statement'
];

names.forEach(function (n) {
  var gr = new GlideRecord('sys_metadata');
  gr.addQuery('sys_update_name', n);
  gr.query();
  if (!gr.next()) {
    gs.info(n + ' -> NOT FOUND (see section 7)');
  } else {
    gs.info(n + ' -> class=' + gr.getValue('sys_class_name') +
            ' | updated=' + gr.getValue('sys_updated_on') +
            ' | mod_count=' + gr.getValue('sys_mod_count'));
  }
});

What to actually learn: when a name has two possible readings, stop reasoning and query. The platform already knows the answer.

7. When the Record Genuinely Is Not There

Sometimes you query correctly and still get zero rows. That is often fine. These are the causes, most to least common.

CauseWhat is happeningHow to confirm
Conditional contentThe payload ships records for optional dependencies; inactive ones are skipped silentlysys_store_app.conditional_content; check the plugin in sys_plugins
Legacy upgrade-path artifactThe record targets an older data model, retained so old instances can migrateTarget table absent from sys_db_object
Target table absentA dictionary record for a table this install never createdsys_db_object returns 0
Deprecated and deletedShipped once, removed in a later versionQuery sys_metadata_delete
Multi-record fileOne XML carries a primary record plus children; the filename names only the primaryInspect the XML if available
Scope mismatchThe record landed under a different sys_scope than the shipping packageDrop the scope filter; query sys_update_name only

The grc_control file from the previous section turned out to be the second case. grc_control is the legacy global-scope GRC table from before the suite was re-platformed into scoped apps, superseded by sn_compliance_control. The column sn_policy_compliance_statement is a migration bridge linking a legacy control to a new-model control objective. The instance had only the modern scoped apps and no legacy GRC plugin, so the file had no target and was a silent no-op.

That is exactly the behaviour one of the release notes was describing when it mentioned "migrated ... to conditional plugin structure." Conditional content is the mechanism that lets a single payload serve both legacy and modern instances.

The decision tree

START:  log line "Loading update: pkg/update/FILE.xml"
   |
   v
[1] Query sys_metadata where sys_update_name = FILE  (drop the .xml)
   |
   +-- FOUND ------> Check sys_updated_on + sys_mod_count
   |                    |
   |                    +-- mod_count incremented --> CHANGED by this install
   |                    |
   |                    +-- unchanged -------------> no-op (normal, ignore)
   |
   +-- NOT FOUND --> [2] Does the target table exist?  (sys_db_object)
                        |
                        +-- NO --> conditional content, or legacy
                        |          upgrade-path artifact  =>  BENIGN
                        |
                        +-- YES -> [3] Query sys_metadata_delete
                                      |
                                      +-- FOUND --> deprecated and removed
                                      |             by a later version
                                      |
                                      +-- NOT FOUND --> [4] Upgrade History
                                                         -> Skipped changes
                                                         *** ACTIONABLE ***

Only the last branch is actionable. A skipped change means a delivered fix was blocked by a local customization. The fix is in the payload, but not on your instance.

8. The One List Everybody Should Read After an Upgrade

System Diagnostics → Upgrade History → open the run → Skipped changes.

That is where the vendor's fix and your customization collided, and the customization won. Filter it by table to triage fast:

Filter onWhat it tells you
sys_security_acl_rolePermission fixes that did not land
sys_scriptBusiness rule fixes that did not land
sys_dictionarySchema changes that did not land

For each entry you then make a decision: accept your customization and document why, or revert to the vendor version and retest. Both are valid. Silently ignoring the list is not.

What to actually learn: a clean-looking install log plus a non-empty Skipped changes list is the most common way for a fix to be "delivered" and still absent.

9. Verifying Permission Fixes: Read the ACL, Not the Release Note

In the example, one release note claimed "Granted Compliance Library Reader and Compliance Reader roles access to Policy category." Checking the ACLs directly told a different story. The read ACL on the Policy Category table granted:

  • sn_compliance.reader: present
  • sn_compliance.policy_reader: present
  • sn_compliance.library_reader: absent

Absent from all seven ACLs on that table, in fact. And sys_user_role_contains offered no inherited path: library_reader only contained a role in a different scope. No ACL on that table had been touched during the upgrade window at all; the most recent change predated it by six months.

So half the release note was already true before the upgrade, and the other half was not true after it. That is a genuine, user-visible permission gap, the kind of thing that would otherwise surface as a help-desk ticket months later.

The permission verification recipe

StepTableWhat you check
1sys_security_aclAll ACLs on the target table, by operation (read, write, create, delete)
2sys_security_acl_roleWhich roles each ACL requires
3sys_user_role_containsWhether the role in the release note is granted through inheritance from another role
4sys_auditWhether any of those rows were modified inside the install window
5ImpersonationOpen the record as a user holding only the role in question

What to actually learn: when a release note says "granted role X access to Y," verify it by reading the ACL and its role rows. Do not forget sys_user_role_contains, because the grant may be intended via inheritance. If neither path exists, you have found a real gap.

10. For Logic Fixes, Find the Live Code Path First

Some fixes can only be proven by behaviour. But before writing tests, find out which code actually runs, because mature apps are full of dual-path logic from mid-migration eras.

A business rule in the example read, roughly:

if (grcUtils.isWorkflowActive("Policy exception")) {
    // legacy wf_workflow branch
} else {
    grcUtils.verifyAndCancelWorkflowContexts('Policy Exception', current);
    grcUtils.checkActiveAndCancelFlow('Policy Exception', current);
}

Two branches: legacy Workflow and modern Flow Designer. A quick query settled which one was live. wf_workflow had zero matching records, and the workflow sys_id hard-coded in a sibling business rule did not exist on the instance at all. Everything ran through the Flow branch.

That one check eliminated an entire category of wrong tests (debugging a legacy workflow that is not there) and pointed at the real mechanism: a published Flow whose auto-close was a Wait-For-Condition on valid_to <= gs.endOfCurrentMinute() feeding an Update Record action.

A nice forensic detail: the flow's label_cache still referenced a Timer instance keyed on valid_to that no longer existed among its live actions. It is a fossil of the redesign from Timer to Wait-For-Condition. Stale label_cache entries are a quiet signal that a flow's structure changed.

What to actually learn: before testing workflow behaviour, confirm whether the Flow or the legacy Workflow is live. wf_workflow returning zero rows is a definitive answer.

11. Timezone Fixes Need Timezone Tests

One release note said an effective-date validation was "incorrectly flagging the current date as past." The implementation showed why, and it is a pattern worth recognising anywhere:

// client-callable script include
isDateInPast: function() {
    var dateValue = new GlideDateTime(this.getParameter('sysparm_date')).getNumericValue();
    var nowDate   = new GlideDateTime().getLocalDate().getNumericValue();
    return dateValue < nowDate;
}

A single < compares a datetime built from a raw string (interpreted as internal, UTC) against a date in the session's timezone. Mix a datetime with a date, and UTC with user-local, and the boundary misfires: for users behind UTC in their local evening, and for users ahead of UTC in their local morning.

The server-side business rule had the same shape: getValue() (internal, UTC) compared against new GlideDateTime().getLocalDate() (session-local).

Why the boundary hours matter

Two quick examples show how the same "today" can be two different calendar dates at once.

UserLocal timeUTC at that momentWhere it goes wrong
US/Pacific (UTC-8 in November)Nov 20, 6:00 PMNov 21, 02:00UTC has already rolled to the next day
Australia/Sydney (UTC+11 in November)Nov 21, 8:00 AMNov 20, 21:00UTC is still on the previous day

The test plan

So the test plan is not "set the date to today." It is:

  • A user in the instance timezone: today is accepted, yesterday is rejected, tomorrow is accepted.
  • A user behind UTC (for example US/Pacific), tested in their local evening, when UTC has already rolled over. Today must still be accepted.
  • A user ahead of UTC (for example Australia/Sydney), tested in their local early morning, when UTC is still on the previous day.
  • Both layers independently: client (onChange message) and server (bypass the client script via list edit or import). A mismatch between the two is a common residual bug.

And assert on the exact error string, not on "an error appeared." The string is the stable contract. In this case the same message was emitted by both the business rule and the client script, so one assertion covered both paths.

What to actually learn: any date-validation fix is a timezone-boundary test. Stage test users on both sides of UTC before you start, and run them at the hours where the dates disagree.

12. Know When to Stop Looking in Tables

Two of the ten release notes were simply not verifiable from metadata, and recognising that fast saves real time.

"Migrated query range access controls to conditional plugin structure"

query_range turned out to be an ACL operation (there is a sys_security_operation record for it), not a table. Eighty-four such ACLs existed in the app's scope, all created seven months before the upgrade, none touched by it, all plain ACLs with no condition or script. The migration is a packaging-time decision about which payload ships for which release. There is no post-upgrade delta to find.

The only sensible checks: confirm conditional_content = 1 and that compatibilities lists the target release, then spot-check that range filters (>, <, BETWEEN) still work for a non-admin. The real payoff arrives at the next platform upgrade.

"Added indexing to a queue table's queries"

sys_index had zero rows for the table and, tellingly, zero rows for incident either, and only about 37 rows instance-wide. sys_index is not a reliable complete catalog of physical indexes. Physical indexes get applied at install time without necessarily writing metadata rows.

So for index changes, go to the database layer instead:

  • System Definition → Tables → the table → related list Database Indexes
  • /stats.do → Database, or System Diagnostics → Stats
  • Best of all: the Slow Query Log, before and after a representative bulk run

What to actually learn: if sys_index returns nothing for a table you know is indexed, the table is not your source of truth. Verify indexes by DB inspection or by measured query performance.

13. Putting It Together: The Scorecard

Here is how the ten release notes in the worked example sorted out. The first six are the ones discussed above; the remaining four reduced to tightly scoped functional tests against named artifacts.

Release note (paraphrased)VerdictEvidence or method
"Next run date" read-only in IRM indicatorsConfirmed in datasys_audit: dictionary record flipped from read-only to editable inside the install window
Library Reader and Reader roles access to Policy categoryGenuine gapACL and role rows: library_reader absent from all seven ACLs; no inheritance path
Effective-date validation flags today as pastNeeds functional testTimezone-boundary tests on client and server layers
Policy exception auto-closeNeeds functional testLive path is the Flow; test the Wait-For-Condition and Update Record behaviour
Query range ACLs migrated to conditional structureNot verifiable via metadataStatic check of conditional_content and compatibilities; spot-check range filters
Indexing added to a queue tableNot verifiable via metadataDB-layer inspection or slow query measurement
Four remaining itemsNeeds functional testScoped tests against the named artifacts

One conclusively confirmed from audit data in minutes, one genuine gap on the instance, two not verifiable from metadata by design, and the rest reduced to focused tests. That is a far better position than "the release notes say it's fixed."

14. Turn It Into a Repeatable Evidence Log

The scorecard is most useful when it is not a one-off. Keep one row per release note in a shared sheet or in the change record, and fill it as you go. A simple structure works well:

ColumnExample
Release noteResolved "Next run date" being read-only
Owning app (actual)sn_grc (not sn_compliance)
BucketConfirmed in data
Evidencesys_audit row, old and new values, timestamp
Query or test usedThe filter or test case, so someone else can rerun it
Result and datePass, with the date and instance
Follow-upNone, or a ticket reference for a gap

The "owning app (actual)" column is the one people skip, and it is the one that prevents you from testing the right fix against the wrong version baseline.

15. A Reusable Post-Upgrade Checklist

BASELINE
[ ] sys_store_app: version, latest_version, update_available, dependencies,
    compatibilities -- for the WHOLE app family, not just the app you upgraded
[ ] Note the install window (start/end timestamps) from the log
[ ] glide.war property, if release notes mention a release-train name

WHAT ACTUALLY CHANGED
[ ] sys_audit for the install window, filtered to sys_dictionary,
    sys_security_acl, sys_security_acl_role, sys_script, sys_ui_policy
[ ] Upgrade History -> Skipped changes    <-- the only reliably actionable list
[ ] For any record of interest: sys_mod_count and sys_updated_on,
    NOT the presence of a "Loading update:" line

TRIAGE EACH RELEASE NOTE
[ ] Sort into: confirmed in data / needs functional test / not verifiable
[ ] Permission fixes  -> read the ACL + sys_security_acl_role
                         + sys_user_role_contains
[ ] Logic fixes       -> identify the LIVE path (Flow vs legacy Workflow) first
[ ] Date fixes        -> timezone-boundary tests, users on both sides of UTC
[ ] Index fixes       -> DB-level inspection or slow-query measurement
[ ] Packaging fixes   -> static check only; revisit at next platform upgrade

FOR ANY LOG LINE YOU CAN'T EXPLAIN
[ ] Query sys_metadata by sys_update_name -- never parse the filename by eye
[ ] Still nothing? Check the target table exists, then sys_metadata_delete,
    then Skipped changes

16. Test Yourself

Knowing the tables is one thing. Spotting the problem under pressure is another. Try these three before reading the answers.

Question 1. Your install log contains Loading update: sn_compliance/update/sys_dictionary_sn_grc_item_owner.xml. You query sys_metadata and find the record with sys_mod_count = 0 and a sys_updated_on from 2021. Did the upgrade change it?

Question 2. A release note says a fix was made in the app you upgraded, but you cannot find the artifact in that app's scope. What should you check next?

Question 3. You search sys_index for a table the release notes say received new indexes, and it returns nothing. Does that mean the index was not added?

Answers: (1) No. The line is emitted for every record on every install; mod count 0 and an old updated date mean it was a no-op. (2) Check the other apps in the family. The artifact may live in a sibling such as sn_grc, and that app may not have been upgraded. (3) No. sys_index is not a complete catalog of physical indexes. Check the table's Database Indexes related list, /stats.do, or measure with the Slow Query Log.

17. Frequently Asked Questions

Why are there so many "Loading update:" lines if so little changes?
Because the installer processes every record in the payload every time. It then decides per record whether anything needs to be written. The log line records the attempt, not the outcome.

Why can't I find an update set or version record for a store app upgrade?
Store-app installs typically do not write the update-set style records (sys_update_xml, sys_update_version). Use sys_audit for field-level changes and sys_metadata fields such as sys_mod_count for per-record checks.

Is a record that is not found always a problem?
No. Conditional content and legacy upgrade-path artifacts routinely have no target on a modern instance. Only a record that is missing while its table exists, is not in sys_metadata_delete, and appears under Skipped changes is actionable.

Do sys_ids help here?
Yes. Sys_ids for vendor-delivered metadata are identical across instances, so they are safe to share and useful for pinpointing a record. Anything created locally on your instance will not match.

Can I trust release notes at all?
Yes, as a map of where to look. Just do not treat them as proof. They describe what the vendor changed in the payload, not what your instance now contains.

Wrap-Up

The thread running through all of this: an install log tells you what the installer attempted, not what your instance now contains. Those are different questions, and only the second one matters.

sys_audit answers it for field changes. Direct ACL and role queries answer it for permissions. sys_mod_count answers it per record. Skipped changes answers it for collisions. And a handful of release notes cannot be answered in tables at all; recognising those early is as valuable as verifying the rest.

If there is one habit to take from this article, it is the question to ask after every upgrade: what did this install actually change on my instance? Ask it with sys_audit and Skipped changes before you write a single test case.


Note: Table names, field names, log wording, navigation paths and tooling details can change between releases and between instances, and audit settings differ per instance. Verify them on your own instance and in the official ServiceNow documentation before relying on them. The version numbers and findings above come from one real upgrade and are shown as an example, not as a statement about every environment. ServiceNow is a trademark of ServiceNow, Inc. This blog is independent and not affiliated with or endorsed by ServiceNow, Inc.