How SAM license reconciliation works across installed and SaaS software. - Support and Troubleshooting

How SAM license reconciliation works across installed and SaaS software. Summary .ns-kb-css-body-editor-container { p { font-size: 12pt; font-family: Lato; color: var(--now-color--text-primary, #000000); } span { font-size: 12pt; font-family: Lato; color: var(--now-color--text-primary, #000000); } h2 { font-size: 24pt; font-family: Lato; color: var(--now-color--text-primary, black); } h3 { font-size: 18pt; font-family: Lato; color: var(--now-color--text-primary, black); } h4 { font-size: 14pt; font-family: Lato; color: var(--now-color--text-primary, black); } a { font-size: 12pt; font-family: Lato; color: var(--now-color--link-primary, #00718F); } a:hover { font-size: 12pt; color: var(--now-color--link-primary, #024F69); } a:target { font-size: 12pt; color: var(--now-color--link-primary, #032D42); } a:visited { font-size: 12pt; color: var(--now-color--link-primary, #00718f); } ul { font-size: 12pt; font-family: Lato; } li { font-size: 12pt; font-family: Lato; } img { display: ; max-width: ; width: ; height: ; } } Learn how Software Asset Management (SAM) license reconciliation determines your software compliance position across both installed and Software-as-a-Service (SaaS) software.

Reconciliation compares what you own against what you actually use and produces your license position, answering one core question: are you compliant with your software licensing, and by how much?

This article explains the process from end to end so you can understand, validate, and troubleshoot the results.

The three quantities reconciliation compares:

Every reconciliation weighs three things for each piece of software:

Quantity Meaning Where it lives Entitlements (own) The rights you purchased alm_license (rights, license metric, software model, downgrade rights); group allocations in alm_entitlement_group Consumption (use) What is deployed or consumed Installs in cmdb_sam_sw_install ; SaaS seats in samp_sw_subscription ; SaaS usage rolled into sam_saas_consumption_summary Position (result) Owned vs. used, plus the financial outcome samp_license_metric_result , rolled up to samp_software_model_result The position resolves to one of three outcomes: compliant, non-compliant (you are short on rights and owe a true-up), or over-licensed (you own more than you use, representing potential savings). How core reconciliation runs :

Reconciliation runs in two ways: - On a schedule — the scheduled job SAM - Software License Reconciliation runs weekly and reconciles all publishers. - On demand — you can run reconciliation for selected publishers (optionally narrowed by group, subgroup, or domain) from the Software Asset Management workspace. This action launches the same engine as a background job and then opens the reconciliation results. Note: Sequence matters. Reconciliation consumes discovered, normalized installation data and your entitlement records. Run discovery and software normalization, and make sure entitlements are loaded, before reconciling — otherwise the resulting position will be incomplete or inaccurate. Once started, the flow is: 1. Build the run. A reconciliation result header is created in samp_reconciliation_result to track status and progress, and work is fanned out per publisher.

2. Select a calculator per license metric. For each software model, the engine looks at the license metric on the entitlement (for example per-device, per-core, per-user, named user, or processor) and selects the matching license calculator. SAM Pro ships roughly 40 calculators covering common metrics plus publisher-specific models for Oracle, SAP, IBM, Microsoft, and Red Hat.

3. Consume rights in passes. Each calculator first consumes rights that are explicitly allocated to a user or device, then draws from the shared unallocated pool. Some metrics add a concurrent-use pass.

4. Broker the rights. A central rights broker allocates available rights in the order allocated, unlimited, then unallocated, compares the rights needed against the rights owned, and when there is a shortfall, books it against the most cost-effective entitlement.

5. Mark each consumer. Every install or subscription is stamped with its result — the software model and license metric it was satisfied by, whether it is licensed, and whether allocation is needed.

6. Summarize and explain. Installs are grouped into Licensed, Ignored, Requiring Action, and Unlicensed buckets, and human-readable explanations are generated describing why a given item required the licenses it did. Reading the result :

The keystone result record is the license metric result (samp_license_metric_result), written per software model and license metric. It holds all three quantities together: - Owned: licenses/rights owned, downgrade rights, whether the license is unlimited. - Used: licenses required, rights used, rights needed, peak consumption. - Position: licenses available, rights available, over-licensed amount, true-up cost, potential savings, and total spend. These roll up into the software model result (samp_software_model_result), which carries the headline compliance status and aggregate counts, and then further into product and publisher results. A shortage (licenses required exceeds licenses owned) drives true-up cost; a surplus drives over-licensed amount and potential savings. At the individual item level, an install or subscription is: - Licensed — covered by a license metric result. - Unlicensed — evaluated, but not covered by available rights. - Requiring Action — flagged as needing attention. - Ignored — reconciled but intentionally not counted.

Allocation and assignment:

Rights can be allocated to specific users or devices, and reconciliation always consumes allocated rights before drawing from the shared pool. Group allocation assigns entitlements to members of a group based on a condition: matching entitlements are found, per-user allocations are created, and the group is marked Fully, Partially, or Not allocated. A weekly SAM - Sync group allocations job keeps these current.

SaaS subscription reconciliation and reclamation :

SAM SaaS License Management extends the same model to vendor-hosted applications such as Microsoft 365, Slack, Zoom, GoTo, Jira, Asana, and GitHub.

Each SaaS vendor account is represented as an integration profile, and per-vendor flows handle the lifecycle. The pattern is roughly three flows per vendor — Download Subscriptions, Update User Activity, and Reclaim Subscription. Stage What happens Connect An integration profile is created for the vendor; connection credentials and scheduled jobs are provisioned, and a baseline watching-from date is recorded. Download Subscriptions Subscriptions/entitlements are pulled from the vendor; one row per user-subscription is written to samp_sw_subscription . Update User Activity Per-user usage is pulled into samp_sw_usage , and each subscription's last activity date is stamped — this is the signal used for reclamation. Match Subscriptions are matched to ServiceNow users (by email, then user principal name) and to software models (by vendor SKU). Unrecognized SKUs are recorded for review. Generate candidates Subscriptions that are idle beyond the configured threshold become reclamation candidates in samp_sw_reclamation_candidate . Reclaim The reclaim flow calls the vendor API to revoke or downgrade the license, then removes the local subscription record. What makes a subscription a reclamation candidate : A reclamation rule (samp_sw_reclamation_rule) defines an inactivity threshold in days, an optional condition, and notification settings.

A subscription is considered stale when its last activity date falls on or before the threshold. If a subscription has never shown activity, the evaluation falls back to its creation date (or the profile's baseline watch date, whichever is later).

For some vendors, additional optimization candidates are generated beyond pure inactivity — for example low usage, duplicate licenses, or downgrade opportunities — each with an estimated savings figure. How SaaS connects to your overall license position :

SaaS is not a separate silo. SaaS subscriptions and usage feed the same reconciliation engine and the same software models and entitlements as installed software: - SaaS registers its own consumption calculator into the core engine, so SaaS consumption is reconciled the same way installs are and produces the same kind of license metric result.

- Business rules roll SaaS subscriptions, usage, and cost up into each software model's usage summary as subscriptions and entitlements change.

- SaaS subscriptions reference the same software models and entitlements, so cloud and on-premises consumption land in one combined compliance picture. In short: vendor usage updates each subscription's last activity and a consumption summary; business rules update the software model's usage summary; and core reconciliation then produces the same license position object it produces for on-premises installs — giving you one consolidated view across installed and SaaS software.

Key tables for reference :

Table Holds alm_license Entitlements (rights owned, license metric, software model) alm_entitlement_group Group allocation definitions cmdb_sam_sw_install Discovered software installations samp_sw_subscription SaaS subscriptions (one per user-subscription) samp_sw_usage SaaS per-user usage facts sam_saas_consumption_summary SaaS consumption rolled up for reconciliation samp_sw_reclamation_rule Inactivity rules that drive reclamation samp_sw_reclamation_candidate Proposed reclamations samp_reconciliation_result Reconciliation run header (status/progress) samp_license_metric_result License position per software model and metric samp_software_model_result Software-model compliance rollup and true-up cost Related Links .ns-kb-css-body-editor-container { p { font-size: 12pt; font-family: Lato; color: var(--now-color--text-primary, #000000); } span { font-size: 12pt; font-family: Lato; color: var(--now-color--text-primary, #000000); } h2 { font-size: 24pt; font-family: Lato; color: var(--now-color--text-primary, black); } h3 { font-size: 18pt; font-family: Lato; color: var(--now-color--text-primary, black); } h4 { font-size: 14pt; font-family: Lato; color: var(--now-color--text-primary, black); } a { font-size: 12pt; font-family: Lato; color: var(--now-color--link-primary, #00718F); } a:hover { font-size: 12pt; color: var(--now-color--link-primary, #024F69); } a:target { font-size: 12pt; color: var(--now-color--link-primary, #032D42); } a:visited { font-size: 12pt; color: var(--now-color--link-primary, #00718f); } ul { font-size: 12pt; font-family: Lato; } li { font-size: 12pt; font-family: Lato; } img { display: ; max-width: ; width: ; height: ; } } Software Asset Management - Reconciliation Process