L1
VP (IT) Questions
Overview
The VP of IT needs strategic financial visibility into software spend, vendor relationships, and renewal planning. Questions focus on total cost control, vendor management, and competitive intelligence.
Primary Components: Knowledge Graph, Experience Center, Copilot
Table of Contents
- Q1: I need to see total spend of software
- Q2: I need to see top 10 vendors and cost
- Q3: I need to see how much each software is per user / or pools of licenses
- Q4: I need the ability to see when licenses are expiring coming up for renewal
- Q5: How we are using the licenses (usage analysis)
- Q6: When was this purchased (purchase history)
- Q7: Who purchased the license (procurement tracking)
- Q8: Who is the sponsor/owner (software ownership)
- Q9: How is pricing structured?
- Q10: Is our license agreement competitive?
- Q11: Do we have unusable credits or unused services?
- Q12: What's the utilization rate of our licenses?
- Q13: What are the alternative solutions?
- Q14: What's the proposed renewal increase percentage?
Q1: I need to see total spend of software
Why it matters: Be able to control spend and identify for budgets
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| Procurement | Purchase orders, invoices, contract values | Ariba/Coupa/SAP API | Daily |
| Vendor APIs | Subscription costs, license quantities, SKU pricing | Microsoft Graph /subscribedSkus, Adobe User Mgmt API | Daily |
| Finance | GL entries, payment history, accruals | ERP Extract | Monthly |
L1 Analytics (Bronze→Silver)
-- Normalize procurement data
CREATE TABLE silver.procurement_normalized AS
SELECT
canonical_vendor_id,
canonical_software_product_id,
purchase_date,
quantity,
unit_cost,
total_cost,
contract_id,
cost_center_id
FROM bronze.procurement_raw
WHERE is_software = TRUE;
Transformations:
- Canonicalize vendor names via Cerebro Memory (Adobe Inc., Adobe Systems → Adobe Inc.)
- Normalize software product names via Cerebro Memory (MS Office 365, O365 → Microsoft 365)
- Map cost centers to organizational hierarchy
- Convert currencies to base currency (USD)
L2 Analytics (Silver→Gold)
-- Calculate total software spend aggregations
CREATE TABLE gold.software_spend_summary AS
SELECT
org_id,
fiscal_year,
fiscal_quarter,
SUM(total_cost) as total_software_spend,
SUM(CASE WHEN license_type = 'subscription' THEN total_cost END) as subscription_spend,
SUM(CASE WHEN license_type = 'perpetual' THEN total_cost END) as perpetual_spend,
COUNT(DISTINCT canonical_vendor_id) as unique_vendors,
COUNT(DISTINCT canonical_software_product_id) as unique_products
FROM silver.procurement_normalized
GROUP BY org_id, fiscal_year, fiscal_quarter;
Metrics Calculated:
- Total software spend (YTD, QTD, annual)
- Spend by license type (subscription vs. perpetual)
- Spend trend (MoM, QoQ, YoY growth rates)
- Spend per employee (total spend / employee count)
Cerebro Enhancement
- Intelligence: Detect spending anomalies (e.g., unusual spike in Q3)
- Intelligence: Compare spend to industry benchmarks
- Reasoning: Recommend budget allocation optimization
UI Representation
Component: SoftwareSpendOverview card in Experience Center
Visualization:
┌─────────────────────────────────────────────┐
│ Total Software Spend │
├─────────────────────────────────────────────┤
│ $24.3M ▲ 12% YoY │
│ │
│ [==============■] $18.2M Subscription │
│ [======] $ 6.1M Perpetual │
│ │
│ 📊 Spend Trend (Last 12 Months) │
│ ╱╲ ╱╲ │
│ ╱ ╲╱ ╲╱╲ │
│ ─╯ ╲ │
│ │
│ 🔍 Drill into: [By Vendor] [By Dept] │
└─────────────────────────────────────────────┘
Interactions:
- Click on total to see monthly breakdown
- Click vendors to filter by top 10 vendors
- Click departments to see cost center allocation
- Export to CSV for budget planning
Copilot Query Example:
"What's our total software spend this year?"
Answer: "Your organization has spent $24.3M on software so far this fiscal year, which represents a 12% increase compared to last year. The majority ($18.2M or 75%) is subscription-based spending."
Q2: I need to see top 10 vendors and cost
Why it matters: I need to see top groups for spend and managing relationships
Telemetry Sources
Same as Q1 (Procurement + Vendor APIs + Finance)
L1 Analytics (Bronze→Silver)
-- Aggregate spend by vendor
CREATE TABLE silver.vendor_spend AS
SELECT
canonical_vendor_id,
fiscal_year,
fiscal_quarter,
SUM(total_cost) as vendor_spend,
COUNT(DISTINCT canonical_software_product_id) as products_purchased,
COUNT(DISTINCT contract_id) as active_contracts
FROM silver.procurement_normalized
GROUP BY canonical_vendor_id, fiscal_year, fiscal_quarter;
L2 Analytics (Silver→Gold)
-- Rank vendors and calculate concentration
CREATE TABLE gold.vendor_spend_ranked AS
SELECT
org_id,
canonical_vendor_id,
vendor_spend,
products_purchased,
active_contracts,
ROW_NUMBER() OVER (PARTITION BY org_id ORDER BY vendor_spend DESC) as vendor_rank,
vendor_spend / SUM(vendor_spend) OVER (PARTITION BY org_id) * 100 as spend_percentage,
SUM(vendor_spend) OVER (PARTITION BY org_id ORDER BY vendor_spend DESC) /
SUM(vendor_spend) OVER (PARTITION BY org_id) * 100 as cumulative_percentage
FROM silver.vendor_spend;
Metrics Calculated:
- Vendor spend ranking (1-10)
- Spend concentration (% of total)
- Cumulative spend percentage (Pareto analysis)
- Products per vendor
- Contract count per vendor
- Spend per product
Cerebro Enhancement
- Memory: Consolidate vendor entities across M&A (Broadcom acquired VMware → Broadcom)
- Intelligence: Identify vendor relationship tier (Strategic, Preferred, Tactical)
- Intelligence: Detect vendor pricing trends over time
- Reasoning: Recommend vendor consolidation opportunities
UI Representation
Component: TopVendorsTable in Experience Center
Visualization:
┌──────────────────────────────────────────────────────────────┐
│ Top 10 Vendors by Spend │
├──────────────────────────────────────────────────────────────┤
│ Rank │ Vendor │ Annual Spend │ % Total │ Products │ 📊 │
├──────┼───────────────┼──────────────┼─────────┼──────────┼────┤
│ 1 │ Microsoft │ $8.4M │ 34.6% │ 23 │ → │
│ 2 │ Adobe │ $2.1M │ 8.6% │ 8 │ → │
│ 3 │ Salesforce │ $1.9M │ 7.8% │ 5 │ → │
│ 4 │ ServiceNow │ $1.6M │ 6.6% │ 3 │ → │
│ 5 │ Oracle │ $1.4M │ 5.8% │ 12 │ → │
│ 6 │ Google │ $1.2M │ 4.9% │ 7 │ → │
│ 7 │ Atlassian │ $0.9M │ 3.7% │ 6 │ → │
│ 8 │ Zoom │ $0.8M │ 3.3% │ 2 │ → │
│ 9 │ AWS │ $0.7M │ 2.9% │ 15 │ → │
│ 10 │ Slack │ $0.6M │ 2.5% │ 1 │ → │
├──────┴───────────────┴──────────────┴─────────┴──────────┴────┤
│ Top 10 Total: $19.6M (80.7% of total spend) │
│ │
│ 💡 Insight: Top 3 vendors account for 50% of spend - strong │
│ leverage for Enterprise License Agreements │
└────────────────────────────────────────────────────────────────┘
Interactions:
- Click vendor name → Drill into vendor detail page
- Click → arrow → See vendor contracts, products, and renewal dates
- Click 📊 icon → See spend trend for that vendor
- Sort by any column
Copilot Query Example:
"Who are our top 3 software vendors?"
Answer: "Your top 3 vendors are: 1) Microsoft at $8.4M (34.6%), 2) Adobe at $2.1M (8.6%), and 3) Salesforce at $1.9M (7.8%). Together they represent 50% of your total software spend, giving you strong leverage for enterprise agreements."
Q3: I need to see how much each software is per user / or pools of licenses
Why it matters: Be able to control spend and be able to know what charge backs (if applicable) can be allocated
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| IDP (Entra/Okta) | License assignments per user | /users/{id}/licenseDetails | Daily |
| Procurement | License quantities and costs | Purchase order line items | Daily |
| Vendor APIs | SKU pricing, user assignments | Microsoft Graph, Adobe API | Daily |
L1 Analytics (Bronze→Silver)
-- Calculate per-user cost basis
CREATE TABLE silver.license_cost_basis AS
SELECT
l.software_license_id,
l.software_product_id,
l.quantity,
l.unit_cost,
l.total_cost,
l.license_type,
COUNT(DISTINCT la.pii_id) as assigned_users,
CASE
WHEN l.license_type = 'named_user' THEN l.total_cost / NULLIF(l.quantity, 0)
WHEN l.license_type = 'concurrent' THEN l.total_cost / NULLIF(COUNT(DISTINCT la.pii_id), 0)
WHEN l.license_type = 'site' THEN l.total_cost / NULLIF(org_employee_count, 0)
END as cost_per_user
FROM silver.software_license l
LEFT JOIN silver.license_assignment la ON l.software_license_id = la.software_license_id
GROUP BY l.software_license_id;
L2 Analytics (Silver→Gold)
-- Aggregate cost by software product with allocation options
CREATE TABLE gold.software_cost_allocation AS
SELECT
sp.software_product_id,
sp.software_name,
sp.vendor_name,
SUM(l.total_cost) as total_annual_cost,
SUM(l.quantity) as total_licenses,
SUM(lcb.assigned_users) as total_assigned_users,
SUM(l.total_cost) / NULLIF(SUM(lcb.assigned_users), 0) as cost_per_assigned_user,
SUM(l.total_cost) / NULLIF(SUM(l.quantity), 0) as cost_per_license,
-- Department allocation
d.department_name,
COUNT(DISTINCT CASE WHEN p.department_id = d.department_id THEN la.pii_id END) as dept_users,
SUM(l.total_cost) *
(COUNT(DISTINCT CASE WHEN p.department_id = d.department_id THEN la.pii_id END) /
NULLIF(SUM(lcb.assigned_users), 0)) as dept_allocated_cost
FROM silver.software_product sp
JOIN silver.software_license l ON sp.software_product_id = l.software_product_id
JOIN silver.license_cost_basis lcb ON l.software_license_id = lcb.software_license_id
LEFT JOIN silver.license_assignment la ON l.software_license_id = la.software_license_id
LEFT JOIN silver.pii p ON la.pii_id = p.pii_id
LEFT JOIN silver.department d ON p.department_id = d.department_id
GROUP BY sp.software_product_id, d.department_id;
Metrics Calculated:
- Cost per license (total cost / quantity)
- Cost per assigned user (total cost / assigned users)
- Cost per active user (total cost / active users)
- Department allocation (proportional by user count)
- Pool size (unassigned licenses)
- Pool value (unassigned licenses × unit cost)
Cerebro Enhancement
- Intelligence: Detect cost anomalies (unusually high per-user cost)
- Intelligence: Compare per-user cost to industry benchmarks
- Reasoning: Recommend license pool sizing optimization
UI Representation
Component: SoftwareCostAllocationTable in Experience Center
Visualization:
┌─────────────────────────────────────────────────────────────────────┐
│ Software Cost Per User & Allocation │
├─────────────────────────────────────────────────────────────────────┤
│ Software │Annual Cost│ Licenses │Users│$/User │Pool│Alloc│ │
├──────────────────┼───────────┼──────────┼─────┼───────┼────┼─────┼──┤
│ Microsoft 365 E3 │ $720K │ 2,000 │1,850│ $389 │150 │ ⚙️ │→ │
│ Microsoft 365 E5 │ $684K │ 1,200 │1,180│ $580 │ 20 │ ⚙️ │→ │
│ Adobe CC │ $288K │ 600 │ 542 │ $531 │ 58 │ ⚙️ │→ │
│ Salesforce │ $432K │ 900 │ 856 │ $505 │ 44 │ ⚙️ │→ │
│ Zoom Enterprise │ $180K │ 2,000 │1,987│ $91 │ 13 │ ⚙️ │→ │
├──────────────────┴───────────┴──────────┴─────┴───────┴────┴─────┴──┤
│ 💡 Pool Value: $67,340 in unassigned licenses across all products │
│ │
│ Allocation Options: [By Department] [By Cost Center] [By Location] │
└───────────────────────────────────────────────────────────────────────┘
Interactions:
- Click ⚙️ → View/edit department chargeback allocation rules
- Click → arrow → Drill into software detail with per-department breakdown
- Click "Pool" → See pool management options
- Export allocation report for finance
Copilot Query Example:
"What's the cost per user for Microsoft 365?"
Answer: "Microsoft 365 E3 costs $389 per assigned user ($720K / 1,850 users) with a pool of 150 unassigned licenses worth $58,350. E5 costs $580 per user ($684K / 1,180 users) with 20 unassigned licenses."
Q4: I need the ability to see when licenses are expiring coming up for renewal
Why it matters: Be able to prepare for license discussions
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| Procurement | Contract start/end dates, renewal terms | Contract management system | Daily |
| Vendor APIs | Subscription end dates, auto-renewal status | Vendor portals | Daily |
| IDP | Current license assignments | /subscribedSkus | Daily |
L1 Analytics (Bronze→Silver)
-- Normalize contract renewal data
CREATE TABLE silver.contract_renewal_tracking AS
SELECT
sl.software_license_id,
sl.software_product_id,
sl.contract_id,
sl.start_date,
sl.end_date,
sl.renewal_type,
sl.notice_period_days,
sl.auto_renew,
sl.end_date - INTERVAL sl.notice_period_days DAY as notice_deadline,
DATEDIFF(sl.end_date, CURRENT_DATE) as days_until_expiry,
CASE
WHEN DATEDIFF(sl.end_date, CURRENT_DATE) <= 30 THEN 'critical'
WHEN DATEDIFF(sl.end_date, CURRENT_DATE) <= 90 THEN 'warning'
WHEN DATEDIFF(sl.end_date, CURRENT_DATE) <= 180 THEN 'upcoming'
ELSE 'future'
END as renewal_urgency,
sl.total_cost as renewal_value
FROM silver.software_license sl
WHERE sl.end_date IS NOT NULL
AND sl.end_date >= CURRENT_DATE;
L2 Analytics (Silver→Gold)
-- Aggregate renewal pipeline with usage context
CREATE TABLE gold.renewal_pipeline AS
SELECT
crt.software_license_id,
sp.software_name,
v.vendor_name,
crt.end_date,
crt.days_until_expiry,
crt.renewal_urgency,
crt.renewal_value,
crt.auto_renew,
crt.notice_deadline,
-- Usage context for renewal decision
sar.assigned,
sar.assigned_active,
sar.assigned_inactive,
sar.assigned_active::FLOAT / NULLIF(sar.assigned, 0) * 100 as utilization_rate,
-- Renewal recommendation
CASE
WHEN sar.assigned_active::FLOAT / NULLIF(sar.assigned, 0) > 0.85 THEN 'renew_full'
WHEN sar.assigned_active::FLOAT / NULLIF(sar.assigned, 0) > 0.60 THEN 'optimize_then_renew'
WHEN sar.assigned_active::FLOAT / NULLIF(sar.assigned, 0) > 0.40 THEN 'reduce_quantity'
ELSE 'consider_cancellation'
END as renewal_recommendation
FROM silver.contract_renewal_tracking crt
JOIN silver.software_product sp ON crt.software_product_id = sp.software_product_id
JOIN silver.software_vendor v ON sp.software_vendor_id = v.software_vendor_id
JOIN gold.software_analytic_report sar ON crt.software_license_id = sar.software_license_id
ORDER BY crt.days_until_expiry ASC;
Metrics Calculated:
- Days until expiry
- Notice deadline (when decision must be made)
- Renewal value ($$$ at stake)
- Utilization rate (for right-sizing)
- Renewal pipeline value (next 30/60/90/180 days)
- Auto-renew risk (high-value contracts on auto-renew)
Cerebro Enhancement
- Intelligence: Analyze historical renewal pricing trends
- Intelligence: Compare renewal terms to market rates
- Intelligence: Predict renewal increase percentage based on vendor patterns
- Reasoning: Generate renewal negotiation strategy (renew, reduce, cancel, switch)
- Reasoning: Recommend optimal renewal timing based on usage trends
UI Representation
Component: RenewalPipelineTimeline in Experience Center
Visualization:
┌──────────────────────────────────────────────────────────────────────┐
│ License Renewal Pipeline │
├──────────────────────────────────────────────────────────────────────┤
│ Timeline View [List View] [Calendar View] │
│ │
│ Next 30 Days (Critical) - $2.4M │
│ ├─ 🔴 Microsoft 365 E5 │ Jan 28 │ $684K │ 94% util │ Renew Full │
│ └─ 🔴 ServiceNow ITSM │ Feb 5 │ $420K │ 78% util │ Optimize │
│ │
│ 31-90 Days (Warning) - $4.1M │
│ ├─ 🟡 Adobe Creative Cloud│ Feb 18 │ $288K │ 90% util │ Renew Full │
│ ├─ 🟡 Salesforce Sales │ Mar 1 │ $432K │ 95% util │ Renew Full │
│ ├─ 🟡 Zoom Enterprise │ Mar 15 │ $180K │ 99% util │ Renew Full │
│ └─ 🟡 Slack Enterprise │ Mar 22 │ $156K │ 45% util │ Reduce 50% │
│ │
│ 91-180 Days (Upcoming) - $7.2M │
│ ├─ 🟢 Oracle Database │ Apr 10 │ $1.2M │ 88% util │ Optimize │
│ └─ 🟢 [12 more...] │ │ │ │ │
│ │
│ 📊 Total Pipeline (Next 180 Days): $13.7M │
│ │
│ ⚠️ 2 contracts on auto-renew require review ($1.1M) │
│ 💡 Optimization potential: $890K savings identified │
└──────────────────────────────────────────────────────────────────────┘
Interactions:
- Click software name → See renewal detail page with negotiation intelligence
- Click urgency indicator (🔴🟡🟢) → Filter by urgency
- Set reminder for notice deadline
- Export renewal calendar for procurement team
- Mark as "In Negotiation", "Renewed", "Cancelled"
Copilot Query Example:
"What licenses are expiring in the next 60 days?"
Answer: "You have 6 licenses expiring in the next 60 days worth $6.5M: Microsoft 365 E5 ($684K, Jan 28), ServiceNow ($420K, Feb 5), Adobe CC ($288K, Feb 18), Salesforce ($432K, Mar 1), Zoom ($180K, Mar 15), and Slack ($156K, Mar 22). Optimization analysis shows potential to reduce Slack by 50% due to 45% utilization."
Q5: How we are using the licenses (usage analysis)
Why it matters: Understanding actual usage patterns to optimize license allocation and identify waste
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| IDP (Entra/Okta) | Last login, license assignments | /users/{id}/licenseDetails, /auditLogs/signIns | Hourly |
| UEM (Intune/Workspace ONE) | Application launch events, usage duration | Device telemetry API | Real-time |
| Vendor APIs | Feature usage, module activation | Microsoft Graph /reports/, Adobe Analytics API | Daily |
| SIEM/Log Aggregation | Application access logs | Splunk/Datadog query API | Real-time |
L1 Analytics (Bronze→Silver)
-- Normalize usage events across telemetry sources
CREATE TABLE silver.software_usage_events AS
SELECT
pii_id,
software_product_id,
usage_timestamp,
usage_type, -- 'login', 'launch', 'feature_use', 'api_call'
usage_duration_seconds,
feature_name,
device_id,
source_system -- 'idp', 'uem', 'vendor_api', 'siem'
FROM bronze.usage_events_raw
WHERE usage_timestamp >= CURRENT_DATE - INTERVAL '90 days';
Transformations:
- Deduplicate usage events across multiple telemetry sources
- Canonicalize software names via Cerebro Memory
- Resolve user identities across systems (email → pii_id)
- Classify usage intensity (light, moderate, heavy)
L2 Analytics (Silver→Gold)
-- Calculate comprehensive usage metrics per license
CREATE TABLE gold.license_usage_analytics AS
SELECT
la.software_license_id,
la.pii_id,
sp.software_name,
-- Basic usage metrics
COUNT(DISTINCT DATE(sue.usage_timestamp)) as days_used_last_90,
MAX(sue.usage_timestamp) as last_usage_date,
DATEDIFF(CURRENT_DATE, MAX(sue.usage_timestamp)) as days_since_last_use,
SUM(sue.usage_duration_seconds) / 3600.0 as total_hours_used,
COUNT(sue.usage_timestamp) as total_usage_events,
-- User classification
CASE
WHEN COUNT(DISTINCT DATE(sue.usage_timestamp)) >= 60 THEN 'power_user'
WHEN COUNT(DISTINCT DATE(sue.usage_timestamp)) >= 30 THEN 'regular_user'
WHEN COUNT(DISTINCT DATE(sue.usage_timestamp)) >= 10 THEN 'occasional_user'
WHEN COUNT(DISTINCT DATE(sue.usage_timestamp)) >= 1 THEN 'rare_user'
ELSE 'never_used'
END as usage_classification,
-- Feature adoption
COUNT(DISTINCT sue.feature_name) as unique_features_used,
MAX(CASE WHEN sue.feature_name IN (SELECT premium_feature FROM ref.premium_features WHERE software_product_id = sp.software_product_id) THEN 1 ELSE 0 END) as uses_premium_features
FROM silver.license_assignment la
JOIN silver.software_product sp ON la.software_product_id = sp.software_product_id
LEFT JOIN silver.software_usage_events sue ON la.pii_id = sue.pii_id AND la.software_product_id = sue.software_product_id
GROUP BY la.software_license_id, la.pii_id, sp.software_name;
Metrics Calculated:
- Active users (used in last 30 days)
- Usage frequency (daily, weekly, monthly, inactive)
- Feature adoption rate (% using premium features)
- Usage intensity distribution (power/regular/occasional/rare/never)
- Average usage hours per user
- License utilization rate (active / total assigned)
Cerebro Enhancement
- Intelligence: Detect usage patterns and anomalies (sudden drop in usage)
- Intelligence: Identify underutilized premium licenses
- Intelligence: Predict future usage trends based on historical patterns
- Reasoning: Recommend license tier optimization (E5 → E3 downgrade)
- Reasoning: Identify candidates for license reclamation
UI Representation
Component: LicenseUsageAnalytics dashboard in Experience Center
Visualization:
┌─────────────────────────────────────────────────────────────────────┐
│ License Usage Analysis │
├─────────────────────────────────────────────────────────────────────┤
│ Software: Microsoft 365 E5 │
│ │
│ Usage Distribution (1,200 licenses) │
│ ┌────────────────────────────────────────────┐ │
│ │ ████████████ 42% Power Users (504) │ 60+ days/90 │
│ │ ██████ 23% Regular Users (276) │ 30-59 days/90 │
│ │ ████ 15% Occasional Users (180) │ 10-29 days/90 │
│ │ ██ 8% Rare Users (96) │ 1-9 days/90 │
│ │ ██ 12% Never Used (144) ⚠️ │ 0 days/90 │
│ └────────────────────────────────────────────┘ │
│ │
│ 📊 Utilization: 88% (1,056 active / 1,200 assigned) │
│ │
│ Feature Adoption │
│ ├─ Teams Advanced Features: 67% ✓ │
│ ├─ Power BI Premium: 34% ⚠️ │
│ ├─ Advanced Threat Protection: 89% ✓ │
│ └─ eDiscovery & Compliance: 12% ⚠️ │
│ │
│ 💡 Insights: │
│ • 144 licenses unused for 90+ days ($83,520 annual waste) │
│ • 276 users not using premium features → E3 candidate ($138K save)│
│ • Usage trending up 5% QoQ │
│ │
│ [Export Report] [Reclamation Plan] [Usage Trends] │
└───────────────────── ────────────────────────────────────────────────┘
Interactions:
- Click user classification → Drill into user list for that category
- Click feature adoption → See per-user feature usage matrix
- Click "Reclamation Plan" → Generate list of licenses to reclaim
- Export usage report for vendor negotiation
- Set usage thresholds for automated alerts
Copilot Query Example:
"How are we using our Microsoft 365 E5 licenses?"
Answer: "Out of 1,200 M365 E5 licenses, 88% are actively used (1,056 users). 42% are power users, but 12% (144 licenses) haven't been used in 90+ days, representing $83K in waste. Additionally, 276 users aren't utilizing premium E5 features and could be downgraded to E3, saving $138K annually."
Q6: When was this purchased (purchase history)
Why it matters: Track procurement timeline, contract anniversary dates, and historical spending patterns for budget planning
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| Procurement | Purchase orders, requisitions, approval dates | ERP/Procurement system API | Daily |
| Finance | Invoice dates, payment dates, GL posting | Finance system API | Daily |
| Vendor APIs | Subscription start dates, trial conversion dates | Vendor portal API | Daily |
| Contract Management | Contract signing dates, amendment dates | CLM system API | Daily |
L1 Analytics (Bronze→Silver)
-- Normalize purchase history across systems
CREATE TABLE silver.purchase_history AS
SELECT
sl.software_license_id,
sl.software_product_id,
sp.software_name,
v.vendor_name,
-- Purchase timeline
po.requisition_date,
po.approval_date,
po.purchase_order_date,
c.contract_signature_date,
inv.invoice_date,
inv.payment_date,
sl.start_date as subscription_start_date,
-- Purchase details
po.purchase_order_number,
c.contract_id,
inv.invoice_number,
po.requestor_pii_id,
po.approver_pii_id,
po.procurement_agent_pii_id,
-- Financial details
po.original_amount,
inv.invoiced_amount,
inv.paid_amount,
sl.total_cost as current_annual_cost
FROM silver.software_license sl
JOIN silver.software_product sp ON sl.software_product_id = sp.software_product_id
JOIN silver.software_vendor v ON sp.software_vendor_id = v.software_vendor_id
LEFT JOIN silver.purchase_order po ON sl.purchase_order_id = po.purchase_order_id
LEFT JOIN silver.contract c ON sl.contract_id = c.contract_id
LEFT JOIN silver.invoice inv ON po.purchase_order_id = inv.purchase_order_id;
Transformations:
- Link purchase records across ERP, finance, and vendor systems
- Calculate procurement cycle time (requisition → payment)
- Identify original purchaser and current owner
- Track price changes across renewals
L2 Analytics (Silver→Gold)
-- Aggregate purchase history with trend analysis
CREATE TABLE gold.purchase_history_analytics AS
SELECT
ph.software_product_id,
ph.software_name,
ph.vendor_name,
-- Timeline metrics
MIN(ph.purchase_order_date) as first_purchase_date,
MAX(ph.purchase_order_date) as most_recent_purchase_date,
COUNT(DISTINCT ph.purchase_order_number) as total_purchases,
COUNT(DISTINCT EXTRACT(YEAR FROM ph.purchase_order_date)) as years_as_customer,
-- Procurement cycle analysis
AVG(DATEDIFF(ph.payment_date, ph.requisition_date)) as avg_procurement_cycle_days,
AVG(DATEDIFF(ph.approval_date, ph.requisition_date)) as avg_approval_time_days,
-- Cost evolution
MIN(ph.original_amount) as lowest_purchase_amount,
MAX(ph.original_amount) as highest_purchase_amount,
AVG(ph.original_amount) as avg_purchase_amount,
SUM(ph.paid_amount) as total_lifetime_spend,
-- Stakeholder tracking
MODE(ph.requestor_pii_id) as primary_requestor,
MODE(ph.approver_pii_id) as primary_approver,
COUNT(DISTINCT ph.requestor_pii_id) as unique_requestors
FROM silver.purchase_history ph
GROUP BY ph.software_product_id, ph.software_name, ph.vendor_name;
Metrics Calculated:
- First purchase date (customer since)
- Purchase frequency (annual, per renewal, ad-hoc)
- Procurement cycle time (req → approval → PO → payment)
- Cost trend (increasing, decreasing, stable)
- Total lifetime spend per product
- Primary stakeholders (requestor, approver, owner)
Cerebro Enhancement
- Memory: Link purchase history across vendor M&A and product rebranding
- Intelligence: Detect purchasing patterns and seasonality
- Intelligence: Identify procurement bottlenecks (long approval times)
- Reasoning: Predict optimal purchase timing based on historical pricing
- Reasoning: Recommend procurement process improvements
UI Representation
Component: PurchaseHistoryTimeline in Experience Center
Visualization:
┌─────────────────────────────────────────────────────────────────────┐
│ Purchase History: Adobe Creative Cloud │
├──────────────────────────────── ─────────────────────────────────────┤
│ Customer Since: March 2018 (6 years, 10 months) │
│ │
│ Purchase Timeline │
│ ├─ 2018 Mar Initial Purchase 300 seats $180K [View PO] │
│ ├─ 2019 Mar Renewal 400 seats $252K ↑40% [View PO] │
│ ├─ 2020 Mar Renewal 450 seats $279K ↑11% [View PO] │
│ ├─ 2021 Mar Renewal 500 seats $315K ↑13% [View PO] │
│ ├─ 2022 Mar Renewal 550 seats $363K ↑15% [View PO] │
│ ├─ 2023 Mar Renewal 600 seats $396K ↑ 9% [View PO] │
│ └─ 2024 Mar Renewal 600 seats $420K ↑ 6% [View PO] │
│ │
│ 📊 Metrics │
│ ├─ Total Purchases: 7 │
│ ├─ Total Lifetime Spend: $2.2M │
│ ├─ Average Annual Increase: 13.2% │
│ ├─ Avg Procurement Cycle: 42 days │
│ └─ Next Renewal: March 2025 (62 days) │
│ │
│ 👤 Stakeholders │
│ ├─ Primary Requestor: Sarah Chen (Creative Director) │
│ ├─ Approver: David Park (VP Marketing) │
│ └─ Procurement Contact: Mike Johnson │
│ │
│ 💡 Insight: Price increases averaging 13% annually - significantly│
│ above market rate (typically 5-8%). Recommend competitive bid. │
│ │
│ [Export History] [View Contracts] [Renewal Analysis] │
└─────────────────────────────────────────────────────────────────────┘
Interactions:
- Click purchase entry → View complete PO, invoice, and contract details
- Click stakeholder name → See all purchases they've requested/approved
- Click "Renewal Analysis" → Compare historical pricing to market rates
- Export purchase history for audit or vendor negotiation
- Set anniversary reminders for renewal planning
Copilot Query Example:
"When did we first purchase Adobe Creative Cloud?"
Answer: "Your organization first purchased Adobe Creative Cloud in March 2018 with 300 seats for $180K. You've been a customer for 6 years 10 months with 7 total purchases. Your spending has grown from $180K to $420K (133% increase), with an average annual price increase of 13.2% - significantly above market rates of 5-8%."
Q7: Who purchased the license (procurement tracking)
Why it matters: Accountability, approval workflow tracking, and identifying software champions for renewal decisions
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| Procurement | Requestor, approver, buyer details | ERP requisition/PO API | Daily |
| IDP | User identity, org chart, department | SCIM /Users, /Groups | Daily |
| Service Desk | Service requests, approval tickets | ServiceNow/Jira Service Mgmt API | Daily |
| Contract Management | Contract signatories, business owners | CLM system API | Daily |
L1 Analytics (Bronze→Silver)
-- Resolve procurement stakeholders
CREATE TABLE silver.procurement_stakeholders AS
SELECT
sl.software_license_id,
sl.software_product_id,
sp.software_name,
-- Requestor information
po.requestor_pii_id,
req_user.display_name as requestor_name,
req_user.email as requestor_email,
req_user.department_name as requestor_department,
req_user.manager_name as requestor_manager,
-- Approver information
po.approver_pii_id,
app_user.display_name as approver_name,
app_user.email as approver_email,
app_user.department_name as approver_department,
-- Procurement agent information
po.procurement_agent_pii_id,
proc_user.display_name as procurement_agent_name,
proc_user.email as procurement_agent_email,
-- Contract owner information
c.business_owner_pii_id,
owner_user.display_name as business_owner_name,
owner_user.email as business_owner_email,
owner_user.department_name as business_owner_department,
-- Timeline
po.requisition_date,
po.approval_date,
po.purchase_order_date
FROM silver.software_license sl
JOIN silver.software_product sp ON sl.software_product_id = sp.software_product_id
LEFT JOIN silver.purchase_order po ON sl.purchase_order_id = po.purchase_order_id
LEFT JOIN silver.contract c ON sl.contract_id = c.contract_id
LEFT JOIN silver.user_directory req_user ON po.requestor_pii_id = req_user.pii_id
LEFT JOIN silver.user_directory app_user ON po.approver_pii_id = app_user.pii_id
LEFT JOIN silver.user_directory proc_user ON po.procurement_agent_pii_id = proc_user.pii_id
LEFT JOIN silver.user_directory owner_user ON c.business_owner_pii_id = owner_user.pii_id;
Transformations:
- Resolve PII IDs to human-readable names and org context
- Link current business owner (may differ from original requestor)
- Track ownership changes over time
- Identify department affiliation for chargeback
L2 Analytics (Silver→Gold)
-- Aggregate procurement patterns by stakeholder
CREATE TABLE gold.stakeholder_procurement_patterns AS
SELECT
ps.requestor_pii_id,
ps.requestor_name,
ps.requestor_department,
-- Procurement activity
COUNT(DISTINCT ps.software_license_id) as total_licenses_requested,
COUNT(DISTINCT ps.software_product_id) as unique_products_requested,
SUM(sl.total_cost) as total_value_requested,
MIN(ps.requisition_date) as first_request_date,
MAX(ps.requisition_date) as most_recent_request_date,
-- Approval metrics
AVG(DATEDIFF(ps.approval_date, ps.requisition_date)) as avg_approval_time_days,
-- Current ownership
COUNT(DISTINCT CASE WHEN ps.business_owner_pii_id = ps.requestor_pii_id THEN ps.software_license_id END) as licenses_currently_owned
FROM silver.procurement_stakeholders ps
JOIN silver.software_license sl ON ps.software_license_id = sl.software_license_id
GROUP BY ps.requestor_pii_id, ps.requestor_name, ps.requestor_department;
Metrics Calculated:
- Requestor/approver for each license
- Total procurement value per person
- Number of software requests per department
- Current business owners
- Approval time by approver
- Ownership transitions (original → current)
Cerebro Enhancement
- Intelligence: Identify "software champions" (frequent requestors)
- Intelligence: Detect approval bottlenecks (slow approvers)
- Intelligence: Track ownership changes (departures, role changes)
- Reasoning: Recommend ownership reassignment for orphaned licenses
- Reasoning: Suggest approval workflow improvements
UI Representation
Component: ProcurementStakeholderView in Experience Center
Visualization:
┌─────────────────────────────────────────────────────────────────────┐
│ Procurement Tracking: Salesforce Sales Cloud │
├─────────────────────────────────────────────────────────────────────┤
│ 📝 Original Purchase (Jan 2020) │
│ ├─ Requestor: Jennifer Martinez (VP Sales) │
│ │ └─ Department: Sales │
│ ├─ Approver: Michael Thompson (CFO) │
│ │ └─ Approval Time: 5 days │
│ ├─ Procurement Agent: Lisa Wang │
│ └─ Purchase Amount: $324,000 (500 licenses) │
│ │
│ 👤 Current Business Owner │
│ ├─ Robert Chen (VP Revenue Operations) │
│ ├─ Department: Sales Operations │
│ ├─ Email: [email protected] │
│ └─ Owner Since: June 2023 (transfer from J. Martinez) │
│ │
│ 📊 Renewal History │
│ ├─ 2021 Renewal: Same owner (J. Martinez) │
│ ├─ 2022 Renewal: Same owner (J. Martinez) │
│ ├─ 2023 Renewal: Owner changed to R. Chen │
│ └─ 2024 Renewal: Same owner (R. Chen) │
│ │
│ 🔔 Upcoming Renewal (March 2025) │
│ └─ Action Required: Confirm R. Chen still owns this contract │
│ │
│ 💡 Related Software Owned by R. Chen: │
│ • Salesforce Sales Cloud ($432K) │
│ • Outreach.io ($156K) │
│ • Gong.io ($240K) │
│ Total Portfolio: $828K │
│ │
│ [Contact Owner] [View Purchase Order] [Transfer Ownership] │
└───────────────────── ────────────────────────────────────────────────┘
Interactions:
- Click stakeholder name → See all software they've requested/own
- Click "Contact Owner" → Email template for renewal discussion
- Click "Transfer Ownership" → Reassign business owner
- View complete approval workflow history
- Export stakeholder report for audit
Copilot Query Example:
"Who purchased our Salesforce licenses?"
Answer: "Salesforce Sales Cloud was originally purchased in January 2020 by Jennifer Martinez (VP Sales) with approval from Michael Thompson (CFO). The current business owner is Robert Chen (VP Revenue Operations) who took ownership in June 2023. Robert also owns Outreach.io and Gong.io, managing a total software portfolio of $828K."
Q8: Who is the sponsor/owner (software ownership)
Why it matters: Clear accountability for renewal decisions, usage optimization, and business justification
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| Contract Management | Business owner, technical owner, executive sponsor | CLM system API | Daily |
| IDP | User status, org chart, role changes | SCIM /Users | Daily |
| HR System | Employee status, terminations, transfers | HRIS API | Daily |
| Procurement | Original requestor, cost center owner | ERP API | Daily |
L1 Analytics (Bronze→Silver)
-- Establish current ownership with org context
CREATE TABLE silver.software_ownership AS
SELECT
sl.software_license_id,
sl.software_product_id,
sp.software_name,
v.vendor_name,
sl.total_cost,
-- Business owner (decision maker)
c.business_owner_pii_id,
bo.display_name as business_owner_name,
bo.email as business_owner_email,
bo.department_name as business_owner_department,
bo.manager_name as business_owner_manager,
bo.employment_status as business_owner_status,
-- Technical owner (administrator)
c.technical_owner_pii_id,
tech.display_name as technical_owner_name,
tech.email as technical_owner_email,
tech.department_name as technical_owner_department,
-- Executive sponsor (budget authority)
c.executive_sponsor_pii_id,
exec.display_name as executive_sponsor_name,
exec.email as executive_sponsor_email,
exec.title as executive_sponsor_title,
-- Cost center allocation
sl.cost_center_id,
cc.cost_center_name,
cc.cost_center_owner_pii_id,
cc_owner.display_name as cost_center_owner_name,
-- Ownership metadata
c.ownership_last_verified_date,
DATEDIFF(CURRENT_DATE, c.ownership_last_verified_date) as days_since_verification
FROM silver.software_license sl
JOIN silver.software_product sp ON sl.software_product_id = sp.software_product_id
JOIN silver.software_vendor v ON sp.software_vendor_id = v.software_vendor_id
LEFT JOIN silver.contract c ON sl.contract_id = c.contract_id
LEFT JOIN silver.user_directory bo ON c.business_owner_pii_id = bo.pii_id
LEFT JOIN silver.user_directory tech ON c.technical_owner_pii_id = tech.pii_id
LEFT JOIN silver.user_directory exec ON c.executive_sponsor_pii_id = exec.pii_id
LEFT JOIN silver.cost_center cc ON sl.cost_center_id = cc.cost_center_id
LEFT JOIN silver.user_directory cc_owner ON cc.cost_center_owner_pii_id = cc_owner.pii_id;
Transformations:
- Distinguish business owner vs technical owner vs executive sponsor
- Flag orphaned licenses (owner terminated/transferred)
- Track ownership verification freshness
- Link ownership to cost center for financial accountability
L2 Analytics (Silver→Gold)
-- Aggregate ownership portfolio and identify issues
CREATE TABLE gold.ownership_portfolio AS
SELECT
so.business_owner_pii_id,
so.business_owner_name,
so.business_owner_department,
so.business_owner_status,
-- Portfolio metrics
COUNT(DISTINCT so.software_license_id) as licenses_owned,
COUNT(DISTINCT so.software_product_id) as unique_products_owned,
COUNT(DISTINCT so.vendor_name) as unique_vendors,
SUM(so.total_cost) as total_portfolio_value,
-- Ownership health
COUNT(CASE WHEN so.business_owner_status != 'active' THEN 1 END) as orphaned_licenses,
COUNT(CASE WHEN so.days_since_verification > 365 THEN 1 END) as unverified_licenses,
MAX(so.days_since_verification) as longest_unverified_days,
-- Upcoming renewals
COUNT(CASE WHEN sl.end_date BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '90 days' THEN 1 END) as renewals_next_90_days,
SUM(CASE WHEN sl.end_date BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '90 days' THEN so.total_cost END) as renewal_value_next_90_days
FROM silver.software_ownership so
JOIN silver.software_license sl ON so.software_license_id = sl.software_license_id
GROUP BY so.business_owner_pii_id, so.business_owner_name, so.business_owner_department, so.business_owner_status;
Metrics Calculated:
- Business owner (decision authority)
- Technical owner (system administrator)
- Executive sponsor (budget authority)
- Ownership portfolio size and value per person
- Orphaned licenses (owner departed/inactive)
- Ownership verification staleness
- Multi-role ownership (same person multiple roles)
Cerebro Enhancement
- Intelligence: Detect ownership gaps (no owner assigned)
- Intelligence: Identify ownership concentration risk (one person owns too much)
- Intelligence: Track ownership transitions and reasons
- Reasoning: Recommend ownership reassignment based on usage patterns
- Reasoning: Suggest ownership consolidation opportunities
UI Representation
Component: SoftwareOwnershipDashboard in Experience Center
Visualization:
┌─────────────────────────────────────────────────────────────────────┐
│ Software Ownership: Microsoft 365 E5 │
├─────────────────────────────────────────────────────────────────────┤
│ 👤 Business Owner (Decision Authority) │
│ ├─ Name: Amanda Rodriguez │
│ ├─ Title: VP IT Operations │
│ ├─ Email: [email protected] │
│ ├─ Department: IT │
│ └─ Status: ✓ Active │
│ │
│ 🔧 Technical Owner (Administrator) │
│ ├─ Name: Kevin Park │
│ ├─ Title: Senior IT Systems Administrator │
│ ├─ Email: [email protected] │
│ ├─ Responsibilities: License provisioning, support escalation │
│ └─ Status: ✓ Active │
│ │
│ 💼 Executive Sponsor (Budget Authority) │
│ ├─ Name: David Chen │
│ ├─ Title: Chief Information Officer │
│ ├─ Email: [email protected] │
│ └─ Budget: IT Operations ($8.4M software budget) │
│ │
│ 💰 Cost Center Allocation │
│ └─ CC-1200: IT Operations (100%) │
│ │
│ 📊 Owner Portfolio (Amanda Rodriguez) │
│ ├─ Total Software Owned: 8 products │
│ ├─ Total Portfolio Value: $3.2M │
│ ├─ Licenses Managed: 4,200 │
│ └─ Next Renewal: Microsoft 365 E5 (Jan 28, $684K) │
│ │
│ ✓ Ownership Last Verified: Dec 15, 2024 (30 days ago) │
│ │
│ [Re-verify Ownership] [Transfer Ownership] [View Portfolio] │
└─────────────────────────────────────────────────────────────────────┘
Interactions:
- Click owner name → View complete ownership portfolio
- Click "Re-verify Ownership" → Send verification email
- Click "Transfer Ownership" → Initiate ownership change workflow
- View ownership history and transitions
- Export ownership report for compliance/audit
Copilot Query Example:
"Who owns our Microsoft 365 licenses?"
Answer: "Microsoft 365 E5 is owned by Amanda Rodriguez (VP IT Operations) as the business owner. Kevin Park is the technical administrator, and David Chen (CIO) is the executive sponsor. Amanda's portfolio includes 8 products worth $3.2M. The ownership was last verified 30 days ago on December 15, 2024."
Q9: How is pricing structured?
Why it matters: Understanding cost components enables accurate budget forecasting and identification of cost optimization opportunities
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| Procurement | SKU line items, add-ons, tier pricing | Purchase order detail API | Daily |
| Vendor APIs | Current pricing catalogs, SKU structure | Vendor portal pricing API | Weekly |
| Finance | Invoice line items with itemized breakdowns | ERP invoice detail | Daily |
| Contract Management | Pricing schedules, tier thresholds, escalation clauses | CLM pricing terms | Daily |
L1 Analytics (Bronze→Silver)
-- Normalize pricing structure data
CREATE TABLE silver.license_pricing_structure AS
SELECT
sl.software_license_id,
sl.software_product_id,
sp.software_name,
v.vendor_name,
-- Base pricing
sl.quantity,
sl.unit_cost as base_unit_cost,
sl.total_cost as base_cost,
-- SKU breakdown
pli.sku_code,
pli.sku_description,
pli.sku_quantity,
pli.sku_unit_cost,
pli.sku_total_cost,
pli.pricing_tier, -- 'base', 'add-on', 'support', 'premium_feature'
-- Pricing model
sl.license_type, -- 'named_user', 'concurrent', 'site', 'usage_based'
sl.billing_frequency, -- 'monthly', 'annual', 'multi-year'
-- Tier structure
pt.tier_name,
pt.tier_min_quantity,
pt.tier_max_quantity,
pt.tier_unit_cost,
-- Escalation
c.price_escalation_percentage,
c.price_escalation_frequency
FROM silver.software_license sl
JOIN silver.software_product sp ON sl.software_product_id = sp.software_product_id
JOIN silver.software_vendor v ON sp.software_vendor_id = v.software_vendor_id
LEFT JOIN silver.purchase_line_item pli ON sl.purchase_order_id = pli.purchase_order_id
LEFT JOIN silver.contract c ON sl.contract_id = c.contract_id
LEFT JOIN silver.pricing_tier pt ON sl.software_product_id = pt.software_product_id
AND sl.quantity BETWEEN pt.tier_min_quantity AND pt.tier_max_quantity;
Transformations:
- Parse invoice line items into base + add-on components
- Identify pricing model (named user vs. consumption-based)
- Map quantities to volume pricing tiers
- Calculate effective price per user across all cost components
L2 Analytics (Silver→Gold)
-- Aggregate pricing analytics with cost breakdown
CREATE TABLE gold.pricing_structure_analytics AS
SELECT
lps.software_product_id,
lps.software_name,
lps.vendor_name,
lps.license_type,
lps.billing_frequency,
-- Base cost breakdown
SUM(CASE WHEN lps.pricing_tier = 'base' THEN lps.sku_total_cost END) as base_subscription_cost,
SUM(CASE WHEN lps.pricing_tier = 'add-on' THEN lps.sku_total_cost END) as add_on_cost,
SUM(CASE WHEN lps.pricing_tier = 'support' THEN lps.sku_total_cost END) as support_cost,
SUM(CASE WHEN lps.pricing_tier = 'premium_feature' THEN lps.sku_total_cost END) as premium_feature_cost,
SUM(lps.sku_total_cost) as total_annual_cost,
-- Unit economics
SUM(lps.sku_total_cost) / NULLIF(SUM(lps.quantity), 0) as effective_cost_per_license,
-- Tier analysis
lps.tier_name,
lps.tier_min_quantity,
lps.tier_max_quantity,
lps.tier_unit_cost,
-- Next tier savings potential
LEAD(lps.tier_unit_cost) OVER (PARTITION BY lps.software_product_id ORDER BY lps.tier_min_quantity) as next_tier_unit_cost,
LEAD(lps.tier_min_quantity) OVER (PARTITION BY lps.software_product_id ORDER BY lps.tier_min_quantity) as next_tier_min_qty,
-- Escalation
lps.price_escalation_percentage,
lps.price_escalation_frequency,
SUM(lps.sku_total_cost) * (1 + lps.price_escalation_percentage / 100.0) as projected_next_year_cost
FROM silver.license_pricing_structure lps
GROUP BY lps.software_product_id, lps.software_name, lps.vendor_name, lps.license_type,
lps.billing_frequency, lps.tier_name, lps.tier_min_quantity, lps.tier_max_quantity,
lps.tier_unit_cost, lps.price_escalation_percentage, lps.price_escalation_frequency;
Metrics Calculated:
- Base subscription cost vs. add-ons vs. support
- Effective cost per license (total cost / quantity)
- Volume tier positioning (current vs. next tier)
- Savings potential from volume tier optimization
- Projected cost after escalation
Cerebro Enhancement
- Memory: Maintain historical pricing structure changes across renewals
- Intelligence: Identify add-on costs with low utilization (paying for unused features)
- Intelligence: Compare pricing structure to industry standards (per-user vs. consumption)
- Reasoning: Recommend pricing model optimization (e.g., switch to usage-based)
- Reasoning: Calculate ROI of reaching next volume tier
UI Representation
Component: PricingStructureBreakdown in Experience Center
Visualization:
┌─────────────────────────────────────────────────────────────────────┐
│ Pricing Structure: Salesforce Sales Cloud │
├─────────────────────────────────────────────────────────────────────┤
│ 📊 Cost Breakdown (Annual: $432,000) │
│ │
│ Base Licenses (900 users) $324,000 75% │
│ ████████████████████████████████▌ │
│ └─ Enterprise Edition @ $360/user │
│ │
│ Add-On Features $72,000 17% │
│ ████████▌ │
│ ├─ Sales Insights $27,000 (300 users @ $90) │
│ ├─ CPQ (Configure Price Quote) $36,000 (200 users @ $180)│
│ └─ Pardot Marketing Automation $9,000 (100 users @ $90) │
│ │
│ Premium Support (24/7) $36,000 8% │
│ ████ │
│ │
│ 💰 Pricing Model: Named User, Annual Billing │
│ │
│ 📈 Volume Tier: Tier 2 (500-999 users) │
│ ├─ Current Tier: $360/user │
│ ├─ Next Tier (1000+ users): $324/user (-10%) │
│ ├─ Users Needed for Next Tier: 100 more users │
│ └─ Potential Savings: $32,400/year if reach 1000 users │
│ │
│ 📊 Price Escalation: 5% annually │
│ └─ Next Year Projected: $453,600 (+$21,600) │
│ │
│ 💡 Insights: │
│ • CPQ add-on has only 45% utilization (90/200 active users) │
│ • Consider reducing CPQ to 100 licenses → Save $18K/year │
│ • Reaching 1000 users saves $32K/year (break-even at 70 new users)│
│ │
│ [Export Breakdown] [Compare Alternatives] [Optimization Plan] │
└─────────────────────────────────────────────────────────────────────┘
Interactions:
- Click cost component → Drill into SKU-level detail
- Click tier information → See complete tier structure
- Click "Optimization Plan" → Generate recommendations
- Export pricing breakdown for vendor negotiation
- Compare current structure to alternative vendors
Copilot Query Example:
"How is our Salesforce pricing structured?"
Answer: "Salesforce Sales Cloud costs $432K annually: $324K for 900 Enterprise licenses ($360/user), $72K in add-ons (Sales Insights, CPQ, Pardot), and $36K for 24/7 support. You're in the 500-999 user tier; reaching 1,000 users drops the rate to $324/user, saving $32K/year. The CPQ add-on is only 45% utilized (90/200 users), presenting an $18K savings opportunity by right-sizing."
Q10: Is our license agreement competitive?
Why it matters: Market benchmarking ensures fair pricing and provides negotiation leverage
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| Procurement | Current pricing, contract terms, discounts | Contract database | Daily |
| Vendor APIs | List pricing, standard discounts | Vendor pricing API | Weekly |
| Cerebro Intelligence | Market benchmarks, peer pricing data | Benchmark database | Monthly |
| Industry Reports | Average pricing by company size/industry | External data feeds | Quarterly |
L1 Analytics (Bronze→Silver)
-- Normalize current contract terms for benchmarking
CREATE TABLE silver.contract_benchmarking AS
SELECT
sl.software_license_id,
sl.software_product_id,
sp.software_name,
v.vendor_name,
-- Current pricing
sl.quantity,
sl.unit_cost,
sl.total_cost,
vp.list_price as vendor_list_price,
(vp.list_price - sl.unit_cost) / NULLIF(vp.list_price, 0) * 100 as discount_percentage,
-- Contract terms
c.contract_term_months,
c.payment_terms,
c.auto_renew,
c.cancellation_terms,
c.price_lock_duration_months,
c.support_tier,
c.sla_uptime_percentage,
-- Organizational context
org.employee_count,
org.industry_vertical,
org.annual_revenue_band
FROM silver.software_license sl
JOIN silver.software_product sp ON sl.software_product_id = sp.software_product_id
JOIN silver.software_vendor v ON sp.software_vendor_id = v.software_vendor_id
JOIN silver.contract c ON sl.contract_id = c.contract_id
LEFT JOIN silver.vendor_pricing vp ON sp.software_product_id = vp.software_product_id
AND vp.effective_date <= CURRENT_DATE
AND vp.end_date >= CURRENT_DATE
CROSS JOIN (SELECT employee_count, industry_vertical, annual_revenue_band FROM ref.organization_profile) org;
Transformations:
- Calculate achieved discount vs. list price
- Normalize contract terms for comparison
- Enrich with organizational context for peer matching
L2 Analytics (Silver→Gold)
-- Compare against market benchmarks
CREATE TABLE gold.competitive_pricing_analysis AS
SELECT
cb.software_product_id,
cb.software_name,
cb.vendor_name,
-- Our pricing
cb.unit_cost as our_unit_cost,
cb.discount_percentage as our_discount,
cb.contract_term_months as our_term,
cb.support_tier as our_support,
-- Market benchmarks (from Cerebro Intelligence)
bm.median_unit_cost as market_median_cost,
bm.p25_unit_cost as market_good_cost,
bm.p10_unit_cost as market_excellent_cost,
bm.median_discount_percentage as market_median_discount,
bm.p75_discount_percentage as market_good_discount,
bm.p90_discount_percentage as market_excellent_discount,
-- Comparison
(cb.unit_cost - bm.median_unit_cost) / NULLIF(bm.median_unit_cost, 0) * 100 as cost_vs_market_pct,
CASE
WHEN cb.unit_cost <= bm.p10_unit_cost THEN 'excellent'
WHEN cb.unit_cost <= bm.p25_unit_cost THEN 'good'
WHEN cb.unit_cost <= bm.median_unit_cost THEN 'average'
WHEN cb.unit_cost <= bm.p75_unit_cost THEN 'below_average'
ELSE 'poor'
END as pricing_competitiveness,
-- Savings potential
CASE
WHEN cb.unit_cost > bm.median_unit_cost
THEN (cb.unit_cost - bm.median_unit_cost) * cb.quantity
ELSE 0
END as potential_savings_to_median,
CASE
WHEN cb.unit_cost > bm.p25_unit_cost
THEN (cb.unit_cost - bm.p25_unit_cost) * cb.quantity
ELSE 0
END as potential_savings_to_good,
-- Peer comparison
pc.avg_cost as peer_avg_cost,
pc.sample_size as peer_sample_size
FROM silver.contract_benchmarking cb
LEFT JOIN cerebro.pricing_benchmarks bm
ON cb.software_product_id = bm.software_product_id
AND cb.employee_count BETWEEN bm.company_size_min AND bm.company_size_max
LEFT JOIN cerebro.peer_pricing pc
ON cb.software_product_id = pc.software_product_id
AND cb.industry_vertical = pc.industry_vertical
AND cb.employee_count BETWEEN pc.company_size_min AND pc.company_size_max;
Metrics Calculated:
- Our price vs. market median/percentiles
- Discount achieved vs. market benchmarks
- Pricing competitiveness rating (excellent/good/average/poor)
- Potential savings to reach market rates
- Peer group comparison (same industry/size)
Cerebro Enhancement
- Memory: Track historical benchmark data to identify pricing trends
- Intelligence: Analyze contract terms holistically (price + support + SLA)
- Intelligence: Identify vendors with consistent above-market pricing
- Reasoning: Generate negotiation talking points with benchmark evidence
- Reasoning: Recommend optimal renewal timing based on market cycles
UI Representation
Component: CompetitivePricingAnalysis in Experience Center
Visualization:
┌─────────────────────────────────────────────────────────────────────┐
│ Competitive Pricing Analysis: Adobe Creative Cloud │
├─────────────────────────────────────────────────────────────────────┤
│ Our Pricing: $700/user/year (600 licenses) │
│ │
│ 📊 Market Comparison │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ Excellent ────────────┤ $580 │ │
│ │ Good (25th %) ──────────────────┤ $620 │ │
│ │ Median (50th) ────────────────────────┤ $660 │ │
│ │ Our Price ─────────────────────────────────┤ $700 │ 🔴 │
│ │ Poor (75th %) ──────────────────────────────────────┤ $740 │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
│ 📈 Competitiveness Rating: BELOW AVERAGE │
│ You're paying 6% above market median │
│ │
│ 💰 Savings Opportunity │
│ ├─ To Market Median ($660/user): $24,000/year │
│ ├─ To Good Rate ($620/user): $48,000/year │
│ └─ To Excellent Rate ($580/user): $72,000/year │
│ │
│ 🏢 Peer Comparison (Tech companies, 2000-3000 employees) │
│ ├─ Average: $640/user (sample: 23 companies) │
│ ├─ Your Position: 9% above peer average │
│ └─ Peer Discount Range: 15-22% off list (yours: 12%) │
│ │
│ 📋 Contract Terms vs. Market │
│ ├─ Contract Length: 1 year (market avg: 2-3 years) ⚠️ │
│ ├─ Support Tier: Standard (peers: 65% have Premier) ⚠️ │
│ ├─ Payment Terms: Annual upfront (market: 43% quarterly) ✓ │
│ └─ Auto-Renew: Yes with 90-day notice (market standard) ✓ │
│ │
│ 💡 Negotiation Leverage Points: │
│ • Your pricing is above median; request 10% discount to match │
│ • Multi-year commitment typically yields 15-20% additional savings│
│ • Peers with similar size getting better terms │
│ │
│ [Export Benchmark Report] [Generate Negotiation Brief] [RFP Mode] │
└─────────────────────────────────────────────────────────────────────┘
Interactions:
- Click market comparison chart → See detailed percentile breakdown
- Click "Peer Comparison" → View anonymized peer pricing data
- Click "Generate Negotiation Brief" → Create vendor-ready talking points
- Export benchmark report for procurement team
- Compare multiple vendors side-by-side
Copilot Query Example:
"Is our Adobe Creative Cloud pricing competitive?"
Answer: "Your Adobe CC pricing of $700/user/year is BELOW AVERAGE - 6% above the market median of $660 and 9% above your peer average of $640 (tech companies, 2000-3000 employees). You're achieving a 12% discount vs. list, while peers get 15-22%. Reaching market median saves $24K/year; reaching the 'good' rate ($620) saves $48K/year. Your 1-year term is shorter than market average (2-3 years); committing multi-year typically unlocks 15-20% additional savings."
Q11: Do we have unusable credits or unused services?
Why it matters: Maximize contract value by identifying and utilizing paid-but-unused features, credits, and bundled services
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| Vendor APIs | Included features, service credits, usage limits | Vendor entitlement API | Daily |
| IDP | Feature-level usage, module activation | Service plan assignment API | Daily |
| Usage Telemetry | Feature access logs, consumption metrics | Vendor analytics API | Daily |
| Contract Management | Bundled services, included credits, expiration dates | CLM entitlement records | Daily |
L1 Analytics (Bronze→Silver)
-- Normalize contract entitlements and actual usage
CREATE TABLE silver.contract_entitlement_usage AS
SELECT
c.contract_id,
c.software_product_id,
sp.software_name,
v.vendor_name,
-- Entitlement details
ce.entitlement_type, -- 'feature', 'credit', 'support_hours', 'training_seats', 'api_calls'
ce.entitlement_name,
ce.entitlement_quantity,
ce.entitlement_value_usd,
ce.expiration_date,
DATEDIFF(ce.expiration_date, CURRENT_DATE) as days_until_expiration,
-- Usage tracking
COALESCE(fu.usage_quantity, 0) as actual_usage_quantity,
COALESCE(fu.usage_percentage, 0) as usage_percentage,
fu.last_usage_date,
DATEDIFF(CURRENT_DATE, fu.last_usage_date) as days_since_last_use,
-- Unused analysis
ce.entitlement_quantity - COALESCE(fu.usage_quantity, 0) as unused_quantity,
(ce.entitlement_quantity - COALESCE(fu.usage_quantity, 0)) * ce.unit_value_usd as unused_value_usd,
CASE
WHEN fu.usage_percentage IS NULL OR fu.usage_percentage = 0 THEN 'never_used'
WHEN fu.usage_percentage < 25 THEN 'severely_underutilized'
WHEN fu.usage_percentage < 50 THEN 'underutilized'
WHEN fu.usage_percentage < 75 THEN 'moderate'
ELSE 'well_utilized'
END as utilization_status
FROM silver.contract c
JOIN silver.software_product sp ON c.software_product_id = sp.software_product_id
JOIN silver.software_vendor v ON sp.software_vendor_id = v.software_vendor_id
JOIN silver.contract_entitlement ce ON c.contract_id = ce.contract_id
LEFT JOIN silver.feature_usage fu
ON ce.entitlement_id = fu.entitlement_id
AND fu.usage_period_start >= CURRENT_DATE - INTERVAL '90 days';
Transformations:
- Link vendor-provided entitlements to actual usage data
- Calculate unused credits and features
- Identify expiring credits approaching deadline
- Quantify value of unused services
L2 Analytics (Silver→Gold)
-- Aggregate unused entitlements with recovery recommendations
CREATE TABLE gold.unused_entitlement_analysis AS
SELECT
ceu.software_product_id,
ceu.software_name,
ceu.vendor_name,
-- Entitlement summary
ceu.entitlement_type,
COUNT(DISTINCT ceu.entitlement_name) as entitlements_count,
SUM(ceu.entitlement_value_usd) as total_entitlement_value,
-- Usage analysis
SUM(CASE WHEN ceu.utilization_status = 'never_used' THEN ceu.unused_value_usd END) as never_used_value,
SUM(CASE WHEN ceu.utilization_status IN ('severely_underutilized', 'underutilized')
THEN ceu.unused_value_usd END) as underutilized_value,
SUM(ceu.unused_value_usd) as total_unused_value,
AVG(ceu.usage_percentage) as avg_utilization_percentage,
-- Expiration risk
COUNT(CASE WHEN ceu.days_until_expiration <= 30 AND ceu.unused_quantity > 0 THEN 1 END) as expiring_in_30_days,
SUM(CASE WHEN ceu.days_until_expiration <= 30 THEN ceu.unused_value_usd END) as expiring_value_30_days,
COUNT(CASE WHEN ceu.days_until_expiration <= 90 AND ceu.unused_quantity > 0 THEN 1 END) as expiring_in_90_days,
SUM(CASE WHEN ceu.days_until_expiration <= 90 THEN ceu.unused_value_usd END) as expiring_value_90_days,
-- Recommendations
CASE
WHEN AVG(ceu.usage_percentage) < 25 THEN 'remove_from_next_renewal'
WHEN AVG(ceu.usage_percentage) < 50 THEN 'reduce_quantity_next_renewal'
WHEN COUNT(CASE WHEN ceu.days_until_expiration <= 90 THEN 1 END) > 0
THEN 'urgent_utilization_campaign'
ELSE 'monitor'
END as recommendation
FROM silver.contract_entitlement_usage ceu
GROUP BY ceu.software_product_id, ceu.software_name, ceu.vendor_name, ceu.entitlement_type;
Metrics Calculated:
- Total value of unused entitlements
- Utilization rate per feature/credit type
- Expiring credits (30/60/90 day windows)
- Never-used features and their value
- Recovery recommendations
Cerebro Enhancement
- Memory: Track historical utilization patterns to predict future use
- Intelligence: Identify feature adoption barriers (complexity, awareness, training)
- Intelligence: Correlate feature usage with user roles/departments
- Reasoning: Generate utilization campaigns for high-value unused features
- Reasoning: Recommend removal from renewal to optimize spend
UI Representation
Component: UnusedEntitlementsMonitor in Experience Center
Visualization:
┌─────────────────────────────────────────────────────────────────────┐
│ Unused Services & Credits Analysis │
├─────────────────────────────────────────────────────────────────────┤
│ Total Unused Value: $124,800 across 12 software products │
│ │
│ ⏰ URGENT: Expiring in Next 30 Days ($42,300) │
│ ├─ 🔴 AWS Training Credits $12,000 Expires: Jan 28 │
│ │ └─ 40 seats unused (40/50) - Never activated │
│ ├─ 🔴 Salesforce Sandbox Licenses $18,000 Expires: Feb 5 │
│ │ └─ 6 environments unused (6/10) - Paid but not provisioned │
│ └─ 🔴 Adobe Stock Credits $12,300 Expires: Feb 15 │
│ └─ 410 credits remaining (82%) - Low awareness in Marketing │
│ │
│ ⚠️ Expiring in 31-90 Days ($39,200) │
│ ├─ 🟡 ServiceNow Premium Support $24,000 Expires: Mar 10 │
│ │ └─ 0 support tickets used in 90 days │
│ └─ 🟡 Microsoft Azure DevOps $15,200 Expires: Apr 1 │
│ └─ 25 test licenses never activated (25/50) │
│ │
│ 📊 Chronic Underutilization ($43,300/year recurring) │
│ ├─ Zoom Webinar Add-on $18,000 Usage: 12% │
│ │ └─ 88 licenses unused - Only Marketing uses, consider reducing │
│ ├─ Salesforce CPQ Advanced $16,200 Usage: 34% │
│ │ └─ 132/200 users never accessed - Training gap identified │
│ └─ DocuSign API Credits $9,100 Usage: 8% │
│ └─ 460K API calls unused - Integration not fully deployed │
│ │
│ 💡 Recovery Actions: │
│ • Schedule AWS training for 40 employees (use credits before loss)│
│ • Provision Salesforce sandboxes for QA team (activate 6 envs) │
│ • Launch Adobe Stock awareness campaign in Marketing dept │
│ • Remove ServiceNow Premium Support at renewal (not being used) │
│ • Reduce Zoom Webinar licenses from 200 to 50 (save $13K/year) │
│ │
│ 📈 Potential Recovery: $42,300 (expiring) + $43,300 (annual savings)│
│ │
│ [Create Utilization Campaign] [Export Report] [Set Alerts] │
└─────────────────────────────────────────────────────────────────────┘
Interactions:
- Click entitlement → See user-level detail and who can use it
- Click "Create Utilization Campaign" → Generate communication plan
- Set expiration alerts (30/60/90 day warnings)
- Export unused credits report for finance/vendor discussion
- Assign recovery tasks to department owners
Copilot Query Example:
"Do we have any unused credits or services?"
Answer: "You have $124,800 in unused services across 12 products. URGENT: $42,300 expires in 30 days - AWS training credits ($12K, 40 unused seats), Salesforce sandboxes ($18K, 6 unused), and Adobe Stock credits ($12K, 82% remaining). Additionally, you have $43,300 in chronic underutilization: Zoom Webinar (12% used), Salesforce CPQ Advanced (34% used), and DocuSign API credits (8% used). Immediate actions can recover $42K expiring value and $43K annual savings."
Q12: What's the utilization rate of our licenses?
Why it matters: License utilization is the primary metric for optimization - identifying waste and right-sizing opportunities
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| IDP | License assignments, last login activity | /users/{id}/licenseDetails, /auditLogs/signIns | Hourly |
| UEM | Application launch events, usage duration | Device telemetry API | Real-time |
| Vendor APIs | Vendor-tracked usage, active users | Vendor analytics API | Daily |
| Procurement | Total purchased quantity | License inventory | Daily |
L1 Analytics (Bronze→Silver)
-- Calculate comprehensive utilization metrics
CREATE TABLE silver.license_utilization AS
SELECT
sl.software_license_id,
sl.software_product_id,
sp.software_name,
sl.quantity as purchased_quantity,
-- Assignment metrics
COUNT(DISTINCT la.pii_id) as assigned_users,
sl.quantity - COUNT(DISTINCT la.pii_id) as unassigned_pool,
-- Activity-based utilization (last 30 days)
COUNT(DISTINCT CASE
WHEN sue.usage_timestamp >= CURRENT_DATE - INTERVAL '30 days'
THEN sue.pii_id
END) as active_30_days,
COUNT(DISTINCT CASE
WHEN sue.usage_timestamp >= CURRENT_DATE - INTERVAL '90 days'
THEN sue.pii_id
END) as active_90_days,
-- Inactive analysis
COUNT(DISTINCT CASE
WHEN la.pii_id IS NOT NULL
AND (sue.usage_timestamp < CURRENT_DATE - INTERVAL '30 days' OR sue.usage_timestamp IS NULL)
THEN la.pii_id
END) as inactive_30_days,
COUNT(DISTINCT CASE
WHEN la.pii_id IS NOT NULL
AND (sue.usage_timestamp < CURRENT_DATE - INTERVAL '90 days' OR sue.usage_timestamp IS NULL)
THEN la.pii_id
END) as inactive_90_days,
-- Never used
COUNT(DISTINCT CASE
WHEN la.pii_id IS NOT NULL AND sue.pii_id IS NULL
THEN la.pii_id
END) as never_used,
-- Utilization calculations
COUNT(DISTINCT CASE WHEN sue.usage_timestamp >= CURRENT_DATE - INTERVAL '30 days' THEN sue.pii_id END)::FLOAT /
NULLIF(sl.quantity, 0) * 100 as utilization_rate_30_days,
COUNT(DISTINCT CASE WHEN sue.usage_timestamp >= CURRENT_DATE - INTERVAL '30 days' THEN sue.pii_id END)::FLOAT /
NULLIF(COUNT(DISTINCT la.pii_id), 0) * 100 as assigned_utilization_rate_30_days
FROM silver.software_license sl
JOIN silver.software_product sp ON sl.software_product_id = sp.software_product_id
LEFT JOIN silver.license_assignment la ON sl.software_license_id = la.software_license_id
LEFT JOIN silver.software_usage_events sue
ON la.pii_id = sue.pii_id
AND la.software_product_id = sue.software_product_id
GROUP BY sl.software_license_id, sl.software_product_id, sp.software_name, sl.quantity;
Transformations:
- Calculate active users at 30/60/90 day windows
- Identify inactive assigned licenses
- Track unassigned pool availability
- Compute multiple utilization rate perspectives
L2 Analytics (Silver→Gold)
-- Aggregate utilization analytics with waste quantification
CREATE TABLE gold.utilization_efficiency_report AS
SELECT
lu.software_product_id,
lu.software_name,
v.vendor_name,
-- Quantity breakdown
lu.purchased_quantity,
lu.assigned_users,
lu.unassigned_pool,
lu.active_30_days,
lu.inactive_30_days,
lu.never_used,
-- Utilization rates
lu.utilization_rate_30_days,
lu.assigned_utilization_rate_30_days,
CASE
WHEN lu.utilization_rate_30_days >= 85 THEN 'excellent'
WHEN lu.utilization_rate_30_days >= 70 THEN 'good'
WHEN lu.utilization_rate_30_days >= 50 THEN 'fair'
WHEN lu.utilization_rate_30_days >= 30 THEN 'poor'
ELSE 'critical'
END as utilization_health,
-- Waste quantification
(lu.purchased_quantity - lu.active_30_days) * sl.unit_cost / 12.0 as monthly_waste_usd,
(lu.purchased_quantity - lu.active_30_days) * sl.unit_cost as annual_waste_usd,
-- Optimization potential
CASE
WHEN lu.utilization_rate_30_days < 50 THEN (lu.purchased_quantity - lu.active_30_days) * 0.8
WHEN lu.utilization_rate_30_days < 70 THEN (lu.purchased_quantity - lu.active_30_days) * 0.6
WHEN lu.utilization_rate_30_days < 85 THEN (lu.purchased_quantity - lu.active_30_days) * 0.4
ELSE 0
END as reclamation_target_quantity,
-- Trend analysis
LAG(lu.active_30_days, 1) OVER (PARTITION BY lu.software_product_id ORDER BY metric_date) as active_30_days_prior_month,
(lu.active_30_days::FLOAT - LAG(lu.active_30_days, 1) OVER (PARTITION BY lu.software_product_id ORDER BY metric_date)) /
NULLIF(LAG(lu.active_30_days, 1) OVER (PARTITION BY lu.software_product_id ORDER BY metric_date), 0) * 100 as usage_trend_mom_pct
FROM silver.license_utilization lu
JOIN silver.software_product sp ON lu.software_product_id = sp.software_product_id
JOIN silver.software_vendor v ON sp.software_vendor_id = v.software_vendor_id
JOIN silver.software_license sl ON lu.software_license_id = sl.software_license_id;
Metrics Calculated:
- Active users (30/60/90 day windows)
- Utilization rate (active / purchased)
- Assigned utilization rate (active / assigned)
- Monthly and annual waste (inactive licenses × cost)
- Reclamation target quantity
- Usage trend (month-over-month growth)
Cerebro Enhancement
- Intelligence: Identify seasonal usage patterns (usage drops during holidays)
- Intelligence: Predict future utilization based on historical trends
- Intelligence: Detect anomalous drops in utilization (investigation trigger)
- Reasoning: Generate prioritized reclamation list (high waste, low friction)
- Reasoning: Recommend optimal license quantity for next renewal
UI Representation
Component: LicenseUtilizationDashboard in Experience Center
Visualization:
┌─────────────────────────────────────────────────────────────────────┐
│ License Utilization Overview │
├─────────────────────────────────────────────────────────────────────┤
│ Portfolio Utilization: 73% (4,285 active / 5,850 purchased) │
│ │
│ 📊 Utilization Distribution │
│ ┌────────────────────────────────────────────────────┐ │
│ │ 85-100% Excellent ████████████ 18 products 31% │ │
│ │ 70-84% Good ████████ 12 products 21% │ │
│ │ 50-69% Fair ██████ 9 products 15% │ │
│ │ 30-49% Poor ████ 6 products 10% │ │
│ │ 0-29% Critical ████████ 13 products 23% │ ⚠️ │
│ └────────────────────────────────────────────────────┘ │
│ │
│ 💰 Waste Analysis │
│ ├─ Unused Licenses: 1,565 (27% of portfolio) │
│ ├─ Annual Waste: $892,400 │
│ ├─ Monthly Waste: $74,367 │
│ └─ Reclamation Potential: $623,680/year (70% of waste) │
│ │
│ 🔴 Critical Underutilization (13 products requiring attention) │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Product │Purchased│Active│Util%│Waste/Year│Action │ │
│ ├──────────────────────┼─────────┼──────┼─────┼──────────┼───────┤ │
│ │ Tableau Creator │ 250 │ 42 │ 17% │ $104,520 │Reduce │ │
│ │ Miro Enterprise │ 400 │ 89 │ 22% │ $93,300 │Reduce │ │
│ │ Lucidchart Team │ 180 │ 51 │ 28% │ $25,800 │Review │ │
│ │ Microsoft Visio Pro │ 320 │ 86 │ 27% │ $46,800 │Reduce │ │
│ │ Zoom Webinar │ 200 │ 24 │ 12% │ $52,800 │Cancel │ │
│ └────────────────────────────────────────────────────────────────┘ │
│ │
│ ✅ Excellent Utilization (18 products) │
│ • Microsoft 365 E3: 98% (1,960/2,000) │
│ • Slack Enterprise: 97% (1,940/2,000) │
│ • Zoom Enterprise: 99% (1,987/2,000) │
│ • Salesforce Sales: 95% (856/900) - trending up 3% MoM │
│ │
│ 📈 Trending Up (6 products showing growth) │
│ • Figma Enterprise: 78% → 84% (+8% MoM) │
│ • Notion Team: 62% → 71% (+14% MoM) │
│ │
│ 📉 Trending Down (4 products requiring investigation) │
│ • Adobe Acrobat Pro: 88% → 79% (-10% MoM) ⚠️ │
│ • Atlassian Confluence: 82% → 74% (-10% MoM) ⚠️ │
│ │
│ [Reclamation Plan] [Export Report] [Set Utilization Alerts] │
└─────────────────────────────────────────────────────────────────────┘
Interactions:
- Click product name → Drill into user-level utilization detail
- Click "Reclamation Plan" → Generate prioritized inactive user list
- Click health indicator → Filter by utilization tier
- Set utilization threshold alerts (notify when drops below target)
- Export utilization report for vendor negotiation
Copilot Query Example:
"What's the utilization rate of our software licenses?"
Answer: "Your portfolio utilization is 73% (4,285 active users out of 5,850 purchased licenses). You have excellent utilization on 18 products (31%), but 13 products (23%) are critically underutilized (<30%). The unused 1,565 licenses represent $892K annual waste. Top opportunities: Tableau Creator (17% utilized, $105K waste), Miro (22%, $93K), and Zoom Webinar (12%, $53K). Reclaiming these inactive licenses can save $624K/year."
Q13: What are the alternative solutions?
Why it matters: Competitive intelligence provides negotiation leverage and informs switching decisions
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| Cerebro Memory | Competitive product catalog, feature matrices | Alternative products database | Weekly |
| Market Intelligence | Vendor market share, G2/Gartner ratings | External data feeds | Monthly |
| Procurement | Current product features and costs | Contract database | Daily |
| Shadow IT Detection | Organically adopted alternatives (CASB + UEM) | CASB/UEM discovery API | Daily |
L1 Analytics (Bronze→Silver)
-- Map products to their competitive alternatives
CREATE TABLE silver.product_alternatives AS
SELECT
sp.software_product_id,
sp.software_name as current_product,
v.vendor_name as current_vendor,
sl.total_cost as current_annual_cost,
sl.quantity as current_quantity,
sl.unit_cost as current_unit_cost,
-- Alternative products (from Cerebro Memory)
alt.alternative_product_id,
alt.alternative_product_name,
alt.alternative_vendor_name,
alt.product_category,
alt.market_position, -- 'leader', 'challenger', 'niche', 'emerging'
-- Pricing comparison
alt.typical_unit_cost_low,
alt.typical_unit_cost_high,
alt.typical_unit_cost_median,
(sl.unit_cost - alt.typical_unit_cost_median) / NULLIF(alt.typical_unit_cost_median, 0) * 100 as price_difference_pct,
-- Feature comparison
alt.feature_parity_score, -- 0-100, how well alternative matches current features
alt.unique_differentiators,
alt.integration_complexity, -- 'low', 'medium', 'high'
-- Market intelligence
alt.g2_rating,
alt.gartner_magic_quadrant_position,
alt.market_share_percentage,
alt.typical_implementation_weeks,
-- Shadow IT indicator
CASE WHEN shadow.software_name IS NOT NULL THEN TRUE ELSE FALSE END as organically_adopted_internally
FROM silver.software_product sp
JOIN silver.software_vendor v ON sp.software_vendor_id = v.software_vendor_id
JOIN silver.software_license sl ON sp.software_product_id = sl.software_product_id
JOIN cerebro.alternative_products alt
ON sp.product_category_id = alt.product_category_id
AND alt.alternative_product_id != sp.software_product_id
LEFT JOIN (
-- Detect shadow IT alternatives already in use
SELECT DISTINCT software_name FROM silver.shadow_it_detected
) shadow ON alt.alternative_product_name = shadow.software_name;
Transformations:
- Link current products to category-based alternatives
- Enrich with market intelligence (ratings, reviews, market share)
- Calculate feature parity and cost differentials
- Flag alternatives already organically adopted (shadow IT)
L2 Analytics (Silver→Gold)
-- Rank alternatives by switching potential
CREATE TABLE gold.alternative_solution_analysis AS
SELECT
pa.software_product_id,
pa.current_product,
pa.current_vendor,
pa.current_annual_cost,
pa.current_quantity,
pa.current_unit_cost,
-- Alternative details
pa.alternative_product_name,
pa.alternative_vendor_name,
pa.market_position,
-- Financial comparison
pa.typical_unit_cost_median as alternative_unit_cost,
(pa.current_unit_cost - pa.typical_unit_cost_median) * pa.current_quantity as potential_annual_savings,
pa.price_difference_pct,
-- Switching viability score (0-100)
(
-- Feature parity (40% weight)
pa.feature_parity_score * 0.40 +
-- Cost savings (30% weight)
CASE
WHEN pa.price_difference_pct > 0 THEN LEAST(pa.price_difference_pct, 50) * 0.60
ELSE 0
END +
-- Market position (20% weight)
CASE pa.market_position
WHEN 'leader' THEN 20
WHEN 'challenger' THEN 15
WHEN 'niche' THEN 10
ELSE 5
END +
-- Low implementation complexity (10% weight)
CASE pa.integration_complexity
WHEN 'low' THEN 10
WHEN 'medium' THEN 5
ELSE 0
END +
-- Organic adoption bonus (+10 points)
CASE WHEN pa.organically_adopted_internally THEN 10 ELSE 0 END
) as switching_viability_score,
-- Decision factors
pa.feature_parity_score,
pa.unique_differentiators,
pa.integration_complexity,
pa.g2_rating,
pa.gartner_magic_quadrant_position,
pa.market_share_percentage,
pa.typical_implementation_weeks,
pa.organically_adopted_internally,
-- Recommendation
CASE
WHEN pa.feature_parity_score >= 80 AND pa.price_difference_pct > 20
AND pa.integration_complexity = 'low' THEN 'strong_switch_candidate'
WHEN pa.feature_parity_score >= 70 AND pa.price_difference_pct > 15 THEN 'evaluate_for_switch'
WHEN pa.price_difference_pct > 25 THEN 'negotiation_leverage'
ELSE 'monitor_market'
END as recommendation,
ROW_NUMBER() OVER (
PARTITION BY pa.software_product_id
ORDER BY (
pa.feature_parity_score * 0.40 +
CASE WHEN pa.price_difference_pct > 0 THEN LEAST(pa.price_difference_pct, 50) * 0.60 ELSE 0 END +
CASE pa.market_position WHEN 'leader' THEN 20 WHEN 'challenger' THEN 15 WHEN 'niche' THEN 10 ELSE 5 END +
CASE pa.integration_complexity WHEN 'low' THEN 10 WHEN 'medium' THEN 5 ELSE 0 END +
CASE WHEN pa.organically_adopted_internally THEN 10 ELSE 0 END
) DESC
) as alternative_rank
FROM silver.product_alternatives pa;
Metrics Calculated:
- Potential savings per alternative
- Feature parity score (0-100)
- Switching viability score (composite metric)
- Implementation complexity and timeline
- Market positioning (leader/challenger/niche)
- Organic adoption indicator
Cerebro Enhancement
- Memory: Maintain comprehensive alternatives catalog with feature matrices
- Memory: Track switching case studies (who switched, outcomes, costs)
- Intelligence: Detect when employees adopt alternatives via shadow IT
- Intelligence: Analyze vendor pricing trends to identify switching triggers
- Reasoning: Generate RFP specifications based on current usage patterns
- Reasoning: Calculate total cost of ownership including switching costs
UI Representation
Component: AlternativeSolutionsExplorer in Experience Center
Visualization:
┌─────────────────────────────────────────────────────────────────────┐
│ Alternative Solutions: Adobe Creative Cloud │
├─────────────────────────────────────────────────────────────────────┤
│ Current: Adobe Creative Cloud - $700/user/year (600 licenses) │
│ Annual Cost: $420,000 │
│ │
│ 🔍 Top 3 Alternatives (Ranked by Switching Viability) │
│ │
│ 1️⃣ Affinity Suite [Viability: 82/100] 🟢 │
│ ├─ Cost: $170/user/year (-76% vs. Adobe) │
│ ├─ Annual Savings: $318,000 │
│ ├─ Feature Parity: 85% (strong for design, limited video) │
│ ├─ Market Position: Challenger (4.7★ G2, growing market share) │
│ ├─ Implementation: Low complexity (8-12 weeks) │
│ ├─ Differentiators: One-time perpetual option, simpler UX │
│ └─ 💡 12 employees already using via shadow IT │
│ [Recommendation: EVALUATE FOR SWITCH] │
│ │
│ 2️⃣ Canva Enterprise [Viability: 76/100] 🟢 │
│ ├─ Cost: $300/user/year (-57% vs. Adobe) │
│ ├─ Annual Savings: $240,000 │
│ ├─ Feature Parity: 72% (strong design, no Photoshop equivalent)│
│ ├─ Market Position: Challenger (4.8★ G2, fastest growing) │
│ ├─ Implementation: Low complexity (4-6 weeks) │
│ ├─ Differentiators: AI features, collaborative design, templates│
│ └─ 💡 89 employees using free version (organic adoption!) │
│ [Recommendation: NEGOTIATION LEVERAGE / HYBRID MODEL] │
│ │
│ 3️⃣ Figma + CorelDRAW Suite [Viability: 68/100] 🟡 │
│ ├─ Cost: $480/user/year (-31% vs. Adobe) │
│ ├─ Annual Savings: $132,000 │
│ ├─ Feature Parity: 78% (requires two tools for full parity) │
│ ├─ Market Position: Leader (Figma) + Niche (Corel) │
│ ├─ Implementation: Medium complexity (12-16 weeks) │
│ ├─ Differentiators: Figma collaboration + Corel vector power │
│ └─ 💡 Already have Figma licenses (156 users) - expand use? │
│ [Recommendation: HYBRID APPROACH CONSIDERATION] │
│ │
│ 💼 Strategic Options │
│ ├─ Option A: Full switch to Affinity ($318K savings, 85% parity) │
│ ├─ Option B: Hybrid Adobe (power users) + Canva (casual users) │
│ │ └─ Keep 200 Adobe ($140K) + Add 400 Canva ($120K) = $260K │
│ │ └─ Net savings: $160K/year vs. current │
│ ├─ Option C: Use alternatives as negotiation leverage │
│ │ └─ Present alternatives to Adobe, target 25% discount ($105K) │
│ └─ Option D: Expand Figma usage, reduce Adobe footprint │
│ │
│ 📊 Market Intelligence │
│ • Adobe losing market share to Canva (SMB/mid-market segment) │
│ • Affinity gaining traction in enterprises (Forbes 500 adoption) │
│ • Average Adobe-to-Canva hybrid saves 40-50% while maintaining 90%│
│ of creative capability │
│ │
│ [Generate RFP] [Schedule Vendor Demos] [Build Business Case] │
└─────────────────────────────────────────────────────────────────────┘
Interactions:
- Click alternative → See detailed feature comparison matrix
- Click "Generate RFP" → Create vendor-ready requirements document
- Click "Schedule Vendor Demos" → Request trial/POC with alternatives
- Click "Build Business Case" → Generate financial and operational analysis
- Compare multiple alternatives side-by-side
Copilot Query Example:
"What are the alternatives to Adobe Creative Cloud?"
Answer: "Your top 3 Adobe CC alternatives: 1) Affinity Suite at $170/user (-76%, $318K savings) with 85% feature parity and low switching complexity - 12 employees already using it; 2) Canva Enterprise at $300/user (-57%, $240K savings) with 72% parity - 89 employees using free version; 3) Figma + CorelDRAW at $480/user (-31%, $132K savings). Consider hybrid approach: keep 200 Adobe licenses for power users ($140K) + 400 Canva for casual users ($120K) = $260K total, saving $160K/year while maintaining capabilities."
Q14: What's the proposed renewal increase percentage?
Why it matters: Anticipate budget impact and prepare negotiation strategy based on vendor pricing patterns
Telemetry Sources
| Source | Data Retrieved | API Endpoint | Refresh Frequency |
|---|---|---|---|
| Procurement | Historical renewal pricing, contract terms | Contract history API | Daily |
| Vendor Communications | Renewal quotes, price increase notices | Email/contract mgmt integration | Real-time |
| Cerebro Intelligence | Vendor historical increase patterns | Vendor intelligence database | Monthly |
| Market Intelligence | Industry-wide price increase trends | External data feeds | Quarterly |
L1 Analytics (Bronze→Silver)
-- Track renewal pricing history and patterns
CREATE TABLE silver.renewal_pricing_history AS
SELECT
sl.software_license_id,
sl.software_product_id,
sp.software_name,
v.vendor_name,
-- Current contract
sl.quantity as current_quantity,
sl.unit_cost as current_unit_cost,
sl.total_cost as current_total_cost,
sl.start_date as current_start_date,
sl.end_date as current_end_date,
-- Historical pricing (from previous renewals)
rh.renewal_year,
rh.renewal_date,
rh.previous_unit_cost,
rh.renewed_unit_cost,
rh.previous_total_cost,
rh.renewed_total_cost,
-- Calculate increase
(rh.renewed_unit_cost - rh.previous_unit_cost) / NULLIF(rh.previous_unit_cost, 0) * 100 as unit_price_increase_pct,
(rh.renewed_total_cost - rh.previous_total_cost) / NULLIF(rh.previous_total_cost, 0) * 100 as total_cost_increase_pct,
-- Renewal quote (if available)
rq.quote_date,
rq.quoted_unit_cost,
rq.quoted_total_cost,
(rq.quoted_unit_cost - sl.unit_cost) / NULLIF(sl.unit_cost, 0) * 100 as proposed_increase_pct,
-- Vendor context
v.typical_annual_increase_pct,
v.recent_pricing_trend -- 'stable', 'increasing', 'aggressive'
FROM silver.software_license sl
JOIN silver.software_product sp ON sl.software_product_id = sp.software_product_id
JOIN silver.software_vendor v ON sp.software_vendor_id = v.software_vendor_id
LEFT JOIN silver.renewal_history rh
ON sl.software_product_id = rh.software_product_id
AND rh.renewal_date >= sl.start_date - INTERVAL '5 years'
LEFT JOIN silver.renewal_quote rq
ON sl.software_license_id = rq.software_license_id
AND rq.quote_status = 'active';
Transformations:
- Link current contracts to renewal history
- Calculate historical increase percentages
- Parse vendor renewal quotes
- Track vendor-wide pricing patterns
L2 Analytics (Silver→Gold)
-- Predict renewal increases and budget impact
CREATE TABLE gold.renewal_increase_forecast AS
SELECT
rph.software_product_id,
rph.software_name,
rph.vendor_name,
rph.current_total_cost,
rph.current_unit_cost,
rph.current_quantity,
rph.current_end_date,
DATEDIFF(rph.current_end_date, CURRENT_DATE) as days_until_renewal,
-- Historical pattern analysis
AVG(rph.unit_price_increase_pct) as avg_historical_increase_pct,
STDDEV(rph.unit_price_increase_pct) as increase_volatility,
MAX(rph.unit_price_increase_pct) as max_historical_increase_pct,
MIN(rph.unit_price_increase_pct) as min_historical_increase_pct,
-- Most recent increase
MAX(CASE WHEN rph.renewal_year = (SELECT MAX(renewal_year) FROM silver.renewal_pricing_history WHERE software_product_id = rph.software_product_id)
THEN rph.unit_price_increase_pct END) as last_renewal_increase_pct,
-- Proposed increase (if quote received)
MAX(rph.proposed_increase_pct) as vendor_proposed_increase_pct,
MAX(rph.quoted_total_cost) as vendor_quoted_total_cost,
-- Predicted increase
COALESCE(
MAX(rph.proposed_increase_pct), -- Use vendor quote if available
rph.typical_annual_increase_pct, -- Otherwise use vendor pattern
AVG(rph.unit_price_increase_pct) -- Or historical average
) as predicted_increase_pct,
-- Budget impact calculation
rph.current_total_cost * (1 + COALESCE(MAX(rph.proposed_increase_pct), rph.typical_annual_increase_pct, AVG(rph.unit_price_increase_pct)) / 100.0) as predicted_renewal_cost,
rph.current_total_cost * COALESCE(MAX(rph.proposed_increase_pct), rph.typical_annual_increase_pct, AVG(rph.unit_price_increase_pct)) / 100.0 as predicted_cost_increase,
-- Negotiation context
CASE
WHEN COALESCE(MAX(rph.proposed_increase_pct), AVG(rph.unit_price_increase_pct)) > rph.typical_annual_increase_pct + 5
THEN 'above_vendor_pattern'
WHEN COALESCE(MAX(rph.proposed_increase_pct), AVG(rph.unit_price_increase_pct)) > 10
THEN 'above_market_rate'
WHEN COALESCE(MAX(rph.proposed_increase_pct), AVG(rph.unit_price_increase_pct)) > 5
THEN 'standard_increase'
ELSE 'favorable_increase'
END as increase_assessment,
-- Market comparison
mkt.industry_avg_increase_pct,
mkt.inflation_adjusted_increase_pct
FROM silver.renewal_pricing_history rph
LEFT JOIN cerebro.market_price_trends mkt
ON rph.software_product_id = mkt.software_product_id
AND YEAR(rph.current_end_date) = mkt.trend_year
GROUP BY rph.software_product_id, rph.software_name, rph.vendor_name,
rph.current_total_cost, rph.current_unit_cost, rph.current_quantity,
rph.current_end_date, rph.typical_annual_increase_pct,
mkt.industry_avg_increase_pct, mkt.inflation_adjusted_increase_pct;
Metrics Calculated:
- Average historical increase percentage
- Most recent renewal increase
- Vendor proposed increase (from quote)
- Predicted increase (quote > vendor pattern > historical avg)
- Budget impact (dollar increase)
- Increase assessment (favorable/standard/aggressive)
- Market comparison
Cerebro Enhancement
- Memory: Track renewal pricing patterns across all customers and vendors
- Intelligence: Detect when vendor increases exceed their historical patterns
- Intelligence: Compare proposed increases to market rates and inflation
- Intelligence: Identify negotiation leverage points (competitor pricing, utilization)
- Reasoning: Generate counter-offer recommendations with justification
- Reasoning: Predict optimal negotiation strategy and timing
UI Representation
Component: RenewalIncreaseForecast in Experience Center
Visualization:
┌─────────────────────────────────────────────────────────────────────┐
│ Renewal Increase Forecast │
├─────────────────────────────────────────────────────────────────────┤
│ 📊 Portfolio Renewal Budget Impact (Next 12 Months) │
│ Current Annual Cost: $24.3M │
│ Predicted Renewal Cost: $26.8M │
│ Forecasted Increase: $2.5M (+10.3%) │
│ │
│ 🔴 HIGH PRIORITY: Aggressive Increases (6 vendors, $1.2M impact) │
│ ┌────────────────────────────────────────────────────────────┐ │
│ │ Vendor │Current│Proposed│%Incr│$ Impact│Assessment │Rnwl│ │
│ ├───────── ──────┼───────┼────────┼─────┼────────┼───────────┼────┤ │
│ │ Salesforce │ $432K │ $562K │ 30% │ +$130K │Above Vendor│Feb│ │
│ │ ServiceNow │ $420K │ $525K │ 25% │ +$105K │Above Vendor│Feb│ │
│ │ Oracle │ $360K │ $450K │ 25% │ +$90K │Above Market│Apr│ │
│ │ Adobe │ $420K │ $504K │ 20% │ +$84K │Above Market│Mar│ │
│ │ Atlassian │ $180K │ $225K │ 25% │ +$45K │Above Vendor│Mar│ │
│ │ Zoom │ $180K │ $207K │ 15% │ +$27K │Above Market│Mar│ │
│ └────────────────────────────────────────────────────────────────┘ │
│ │
│ 📋 Detailed Analysis: Salesforce Sales Cloud │
│ ├─ Current Cost: $432,000 ($480/user, 900 licenses) │
│ ├─ Vendor Quote: $562,080 ($624/user) - 30% increase │
│ ├─ Renewal Date: Feb 1, 2025 (17 days) │
│ │ │
│ ├─ 📈 Historical Pattern │
│ │ 2021 → 2022: +8% │
│ │ 2022 → 2023: +12% │
│ │ 2023 → 2024: +15% │
│ │ 2024 → 2025: +30% PROPOSED ⚠️ │
│ │ └─ Average historical: 11.7% │
│ │ │
│ ├─ 🔍 Assessment: ABOVE VENDOR PATTERN (+18.3 pts) │
│ │ • 30% increase is 2.6× historical average │
│ │ • Industry average for CRM renewals: 8-12% │
│ │ • Inflation-adjusted fair increase: 6% │
│ │ │
│ ├─ 💡 Negotiation Leverage │
│ │ • Utilization: 95% (strong case for renewal) │
│ │ • Contract value: $432K (not large enough for best pricing?) │
│ │ • Alternatives: HubSpot ($384/user, -38%), Zoho ($288/user) │
│ │ • Multi-year discount potential: 15-20% for 3-year term │
│ │ │
│ └─ 🎯 Recommended Counter-Offer │
│ • Target increase: 10% ($475,200 total, $528/user) │
│ • Justification: Match historical average + inflation │
│ • Fallback position: 15% ($496,800) │
│ • Walk-away threshold: 20% ($518,400) │
│ • Alternative action: Initiate HubSpot evaluation │
│ │
│ 🟡 STANDARD INCREASES (8 vendors, $890K, avg 8%) │
│ • Microsoft 365: +5% ($420K → $441K) │
│ • Slack: +8% ($156K → $168K) │
│ • Google Workspace: +6% ($240K → $254K) │
│ │
│ 🟢 FAVORABLE INCREASES (4 vendors, $410K, avg 3%) │
│ • AWS: +3% (inflation-adjusted, favorable) │
│ • GitHub: +2% (competitive pressure keeping increases low) │
│ │
│ [Generate Negotiation Briefs] [Budget Forecast Export] [Set Alerts]│
└─────────────────────────────────────────────────────────────────────┘
Interactions:
- Click vendor → See detailed renewal increase analysis
- Click "Generate Negotiation Briefs" → Create vendor-specific negotiation plans
- Click assessment indicator → Filter by increase severity
- Export budget forecast for finance planning
- Set alerts for quote receipt and renewal deadlines
Copilot Query Example:
"What's the proposed renewal increase for Salesforce?"
Answer: "Salesforce proposed a 30% increase ($432K → $562K), significantly above their historical average of 11.7% and 2.6× higher than market rates (8-12% for CRM). This is an aggressive increase. Your negotiation leverage: 95% utilization (strong renewal case), but alternatives like HubSpot cost 38% less ($384/user vs. $624/user). Recommended counter-offer: 10% increase ($475K) matching historical pattern + inflation. Fallback: 15% ($497K). Walk-away: 20% ($518K), triggering HubSpat evaluation."