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.
| Question | Short 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.
| Verdict | Meaning | How you confirm |
|---|---|---|
| Confirmed in data | A record changed, and you can point at the before and after | sys_audit |
| Needs functional test | Logic changed; only behaviour proves it | Reproduce the original bug |
| Not verifiable via metadata | Packaging-level or database-level change | Static 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.
| App | Scope | Installed | Latest available |
|---|---|---|---|
| Policy and Compliance Management | sn_compliance | 23.0.2 | 23.0.2 |
| GRC: Profiles | sn_grc | 23.0.7 | 23.1.2 |
| GRC: Audit Management | sn_audit | 22.3.1 | 23.0.2 |
| GRC: Operational Resilience | sn_oper_res | 22.3.2 | 23.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.
| Field | Old value | New value |
|---|---|---|
| read_only | 1 | 0 |
| read_only_option | client_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.
| Column | sys_updated_on | sys_mod_count | Verdict |
|---|---|---|---|
| classification | install window, by system | 1 | actually changed |
| respondents | 2023-09-05 | 0 | no-op |
| owner | 2021-05-12 | 0 | no-op |
| profile | 2020-07-09 | 0 | no-op |
| state | 2015-10-22 | 0 | no-op |
| number | 2015-10-14 | 0 | no-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:
| Attribute | Value |
|---|---|
| sys_update_name | sys_dictionary_sn_compliance_m2m_statement_profile_type_sn_compliance_statement |
| Actual table | sn_compliance_m2m_statement_profile_type |
| Actual column | sn_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 pattern | Keyed by | Ambiguous? |
|---|---|---|
| sys_dictionary_<table>_<column>.xml | table + column | yes |
| sys_choice_<table>_<column>_<value>.xml | table + column + value | yes |
| sys_db_object_<sys_id>.xml | sys_id | no |
| sys_script_<sys_id>.xml | sys_id | no |
| sys_security_acl_<sys_id>.xml | sys_id | no |
| sys_ui_policy_<sys_id>.xml | sys_id | no |
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.
| Cause | What is happening | How to confirm |
|---|---|---|
| Conditional content | The payload ships records for optional dependencies; inactive ones are skipped silently | sys_store_app.conditional_content; check the plugin in sys_plugins |
| Legacy upgrade-path artifact | The record targets an older data model, retained so old instances can migrate | Target table absent from sys_db_object |
| Target table absent | A dictionary record for a table this install never created | sys_db_object returns 0 |
| Deprecated and deleted | Shipped once, removed in a later version | Query sys_metadata_delete |
| Multi-record file | One XML carries a primary record plus children; the filename names only the primary | Inspect the XML if available |
| Scope mismatch | The record landed under a different sys_scope than the shipping package | Drop 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 on | What it tells you |
|---|---|
| sys_security_acl_role | Permission fixes that did not land |
| sys_script | Business rule fixes that did not land |
| sys_dictionary | Schema 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
| Step | Table | What you check |
|---|---|---|
| 1 | sys_security_acl | All ACLs on the target table, by operation (read, write, create, delete) |
| 2 | sys_security_acl_role | Which roles each ACL requires |
| 3 | sys_user_role_contains | Whether the role in the release note is granted through inheritance from another role |
| 4 | sys_audit | Whether any of those rows were modified inside the install window |
| 5 | Impersonation | Open 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.
| User | Local time | UTC at that moment | Where it goes wrong |
|---|---|---|---|
| US/Pacific (UTC-8 in November) | Nov 20, 6:00 PM | Nov 21, 02:00 | UTC has already rolled to the next day |
| Australia/Sydney (UTC+11 in November) | Nov 21, 8:00 AM | Nov 20, 21:00 | UTC 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) | Verdict | Evidence or method |
|---|---|---|
| "Next run date" read-only in IRM indicators | Confirmed in data | sys_audit: dictionary record flipped from read-only to editable inside the install window |
| Library Reader and Reader roles access to Policy category | Genuine gap | ACL and role rows: library_reader absent from all seven ACLs; no inheritance path |
| Effective-date validation flags today as past | Needs functional test | Timezone-boundary tests on client and server layers |
| Policy exception auto-close | Needs functional test | Live path is the Flow; test the Wait-For-Condition and Update Record behaviour |
| Query range ACLs migrated to conditional structure | Not verifiable via metadata | Static check of conditional_content and compatibilities; spot-check range filters |
| Indexing added to a queue table | Not verifiable via metadata | DB-layer inspection or slow query measurement |
| Four remaining items | Needs functional test | Scoped 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:
| Column | Example |
|---|---|
| Release note | Resolved "Next run date" being read-only |
| Owning app (actual) | sn_grc (not sn_compliance) |
| Bucket | Confirmed in data |
| Evidence | sys_audit row, old and new values, timestamp |
| Query or test used | The filter or test case, so someone else can rerun it |
| Result and date | Pass, with the date and instance |
| Follow-up | None, 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.
