End User Questions

Overview

End Users need self-service capabilities for software access, troubleshooting, and license management. Questions focus on getting access quickly, resolving issues, and understanding their entitlements.

Primary Components: Copilot, Sidekick, Service Ticketing

Q1: What software do I have access to?
Q2: How do I request new software I need for my job?
Q3: How much does this software cost the company?
Q4: When was my software licensed?
Q5: Who approved my software access?
Q6: Can I switch to a different software tool?
Q7: Who can I ask about software capabilities?
Q8: Why don't I have access to specific software?
Q9: How do I report a software issue?
Q10: What are the alternatives if I can't get approved?
Q11: My role changed - what software should I have now?

Q1: What software do I have access to?

Why it matters: Users need to quickly discover what tools are available to them for productivity, understand their entitlements, and know where to access applications.

Telemetry Sources

Source	Data Retrieved	API Endpoint	Refresh Frequency
IDP (Entra/Okta)	Assigned licenses, SSO applications	`/users/{id}/appRoleAssignments`	Real-time
UEM (Intune)	Installed applications on user devices	`/deviceManagement/managedDevices`	Hourly
Service Catalog	Available software catalog, request status	Service catalog API	Daily

L1 Analytics (Bronze→Silver)

-- Normalize user entitlements across sources
CREATE TABLE silver.user_entitlements AS
SELECT
    la.pii_id,
    la.software_product_id,
    sp.software_name,
    sp.vendor_name,
    sp.category,
    la.assignment_date,
    la.assignment_status, -- 'active', 'pending_provision', 'deprovisioned'
    sp.sso_enabled,
    sp.access_url,
    sp.desktop_app_available,
    sp.mobile_app_available,
    -- Installation status
    CASE WHEN di.device_id IS NOT NULL THEN TRUE ELSE FALSE END as installed_on_device
FROM silver.license_assignment la
JOIN silver.software_product sp ON la.software_product_id = sp.software_product_id
LEFT JOIN silver.device_install di ON la.pii_id = di.pii_id AND la.software_product_id = di.software_product_id
WHERE la.assignment_status IN ('active', 'pending_provision');

Transformations:

Consolidate entitlements across IDP, UEM, and manual assignments
Resolve software product names via Cerebro Memory (consistent naming)
Enrich with access methods (SSO portal, desktop app, mobile app)
Include installation status on user's devices

L2 Analytics (Silver→Gold)

-- Aggregate user software portfolio with categorization
CREATE TABLE gold.user_software_portfolio AS
SELECT
    ue.pii_id,
    u.display_name,
    u.email,
    u.department_name,
    u.job_title,
    -- Portfolio summary
    COUNT(DISTINCT ue.software_product_id) as total_applications,
    COUNT(DISTINCT ue.vendor_name) as unique_vendors,
    COUNT(DISTINCT CASE WHEN ue.assignment_status = 'active' THEN ue.software_product_id END) as active_applications,
    COUNT(DISTINCT CASE WHEN ue.assignment_status = 'pending_provision' THEN ue.software_product_id END) as pending_applications,
    -- By category
    COUNT(DISTINCT CASE WHEN ue.category = 'productivity' THEN ue.software_product_id END) as productivity_apps,
    COUNT(DISTINCT CASE WHEN ue.category = 'collaboration' THEN ue.software_product_id END) as collaboration_apps,
    COUNT(DISTINCT CASE WHEN ue.category = 'development' THEN ue.software_product_id END) as development_apps,
    COUNT(DISTINCT CASE WHEN ue.category = 'design' THEN ue.software_product_id END) as design_apps,
    -- Access methods
    COUNT(DISTINCT CASE WHEN ue.sso_enabled = TRUE THEN ue.software_product_id END) as sso_apps,
    COUNT(DISTINCT CASE WHEN ue.installed_on_device = TRUE THEN ue.software_product_id END) as installed_apps
FROM silver.user_entitlements ue
JOIN silver.user_directory u ON ue.pii_id = u.pii_id
GROUP BY ue.pii_id, u.display_name, u.email, u.department_name, u.job_title;

Metrics Calculated:

Total applications assigned
Active vs. pending provisioning
Applications by category (productivity, collaboration, development, design)
Access methods (SSO, desktop, mobile)
Installation status on user devices
Recently added applications (last 30 days)

Cerebro Enhancement

Memory: Personalized software portfolio by user
Intelligence: Suggest commonly used apps in user's department
Intelligence: Identify underutilized applications assigned to user
Reasoning: Recommend relevant software based on job role and peer usage

UI Representation

Component: Copilot conversational interface with "My Software" card in Sidekick

Visualization:

┌─────────────────────────────────────────────────────────────┐
│ 💬 Copilot                                                  │
├─────────────────────────────────────────────────────────────┤
│ You: What software do I have access to?                    │
│                                                             │
│ 🤖 Copilot: You currently have access to 14 applications:  │
│                                                             │
│    📊 Productivity (5)                                      │
│    • Microsoft 365 (Word, Excel, PowerPoint)               │
│    • Adobe Acrobat Pro                                      │
│    • Notion                                                 │
│                                                             │
│    💬 Collaboration (4)                                     │
│    • Microsoft Teams                                        │
│    • Zoom                                                   │
│    • Slack                                                  │
│    • Miro                                                   │
│                                                             │
│    🛠️ Development (3)                                       │
│    • Visual Studio Code                                     │
│    • GitHub Enterprise                                      │
│    • Postman                                                │
│                                                             │
│    🎨 Design (2)                                            │
│    • Figma                                                  │
│    • Adobe Creative Cloud (Photoshop, Illustrator)         │
│                                                             │
│    [View Full List] [Access My Apps] [Request More]        │
│                                                             │
│    💡 Tip: Click "Access My Apps" to open your SSO portal  │
└─────────────────────────────────────────────────────────────┘

Interactions:

Natural language query: "What software do I have?"
Click "View Full List" → See detailed list with access links
Click "Access My Apps" → Open SSO portal
Click "Request More" → Start software request workflow
Filter by category or vendor

Copilot Query Example:

"What software do I have access to?"

Answer: "You have access to 14 applications across 4 categories: 5 productivity tools (Microsoft 365, Adobe Acrobat, Notion), 4 collaboration tools (Teams, Zoom, Slack, Miro), 3 development tools (VS Code, GitHub, Postman), and 2 design tools (Figma, Adobe Creative Cloud). All are accessible through your SSO portal at apps.company.com."

Q2: How do I request new software I need for my job?

Why it matters: Self-service software requests empower users to quickly get the tools they need while ensuring proper approval and compliance workflows.

Telemetry Sources

Source	Data Retrieved	API Endpoint	Refresh Frequency
Service Desk	Request tickets, approval status	ServiceNow `/table/sc_request`	Real-time
Service Catalog	Available software, pricing, approval matrix	Service catalog API	Daily
IDP	User role, department, manager	SCIM `/Users`	Daily
Procurement	Existing licenses, seat availability	Procurement system API	Hourly

L1 Analytics (Bronze→Silver)

-- Normalize software request workflow data
CREATE TABLE silver.software_requests AS
SELECT
    sr.request_id,
    sr.requestor_pii_id,
    sr.software_product_id,
    sp.software_name,
    sp.vendor_name,
    sr.request_date,
    sr.request_status, -- 'submitted', 'pending_approval', 'approved', 'provisioned', 'rejected'
    sr.approval_required,
    sr.approver_pii_id,
    sr.approval_date,
    sr.rejection_reason,
    sr.provisioning_eta_days,
    sr.fulfillment_date,
    sr.business_justification,
    -- Approval routing
    DATEDIFF(sr.approval_date, sr.request_date) as approval_time_days,
    DATEDIFF(sr.fulfillment_date, sr.approval_date) as provisioning_time_days,
    DATEDIFF(sr.fulfillment_date, sr.request_date) as total_time_to_access_days
FROM bronze.service_request sr
JOIN silver.software_product sp ON sr.software_product_id = sp.software_product_id
WHERE sr.request_type = 'software_access';

Transformations:

Map service requests to canonical software products
Calculate approval and provisioning timelines
Identify approval routing (manager, IT, procurement, security)
Track request status and rejection reasons

L2 Analytics (Silver→Gold)

-- Aggregate request patterns and SLAs
CREATE TABLE gold.software_request_analytics AS
SELECT
    sr.software_product_id,
    sp.software_name,
    sp.vendor_name,
    -- Request volume
    COUNT(DISTINCT sr.request_id) as total_requests,
    COUNT(DISTINCT CASE WHEN sr.request_status = 'approved' THEN sr.request_id END) as approved_requests,
    COUNT(DISTINCT CASE WHEN sr.request_status = 'rejected' THEN sr.request_id END) as rejected_requests,
    COUNT(DISTINCT CASE WHEN sr.request_status = 'provisioned' THEN sr.request_id END) as fulfilled_requests,
    -- Approval metrics
    AVG(CASE WHEN sr.request_status IN ('approved', 'provisioned') THEN sr.approval_time_days END) as avg_approval_time_days,
    AVG(CASE WHEN sr.request_status = 'provisioned' THEN sr.provisioning_time_days END) as avg_provisioning_time_days,
    AVG(CASE WHEN sr.request_status = 'provisioned' THEN sr.total_time_to_access_days END) as avg_total_time_days,
    -- Rejection analysis
    COUNT(DISTINCT CASE WHEN sr.request_status = 'rejected' THEN sr.request_id END)::FLOAT /
        NULLIF(COUNT(DISTINCT sr.request_id), 0) * 100 as rejection_rate_pct,
    MODE(CASE WHEN sr.request_status = 'rejected' THEN sr.rejection_reason END) as most_common_rejection_reason
FROM silver.software_requests sr
JOIN silver.software_product sp ON sr.software_product_id = sp.software_product_id
WHERE sr.request_date >= CURRENT_DATE - INTERVAL '90 days'
GROUP BY sr.software_product_id, sp.software_name, sp.vendor_name;

Metrics Calculated:

Available software in catalog
Request approval routing (manager → IT → procurement)
Average approval time by software
Provisioning SLA (time to access)
Approval/rejection rates
Common rejection reasons

Cerebro Enhancement

Memory: User's previous requests and approval patterns
Intelligence: Predict approval likelihood based on role and justification
Intelligence: Suggest similar approved software (if request likely to be rejected)
Reasoning: Pre-fill business justification based on job role
Reasoning: Route to fastest approval path based on software type

UI Representation

Component: Copilot-guided request workflow in Sidekick portal

Visualization:

┌─────────────────────────────────────────────────────────────┐
│ 💬 Copilot - Software Request Assistant                    │
├─────────────────────────────────────────────────────────────┤
│ You: I need access to Figma for design work                │
│                                                             │
│ 🤖 Copilot: Great! I can help you request Figma access.    │
│                                                             │
│ 📋 Software: Figma Professional                            │
│ 💰 Cost: $144/year per user                                │
│ ⏱️  Typical approval time: 2-3 business days               │
│ ✓ 94% approval rate for Design team members                │
│                                                             │
│ 📝 To complete your request, please provide:               │
│                                                             │
│ Business Justification:                                     │
│ [I need Figma to collaborate with the design team on UI    │
│  mockups for the Q1 product launch]                        │
│                                                             │
│ Manager Approval Required: ✓ Yes (Sarah Chen)              │
│                                                             │
│ 💡 Your request will be routed to:                         │
│    1. Sarah Chen (Manager) - Auto-approved ✓               │
│    2. IT Team - Typically approves in 1 day                │
│                                                             │
│ Alternative: Your team already has Miro. Would you like to │
│ try that first? [Learn More]                               │
│                                                             │
│ [Submit Request] [Browse Alternatives] [Cancel]            │
└─────────────────────────────────────────────────────────────┘

Interactions:

Natural language request: "I need Figma for design work"
Copilot guides through request justification
Pre-filled business case based on role
Shows approval routing and timeline
Suggests alternatives if applicable
Track request status in real-time

Copilot Query Example:

"I need access to Figma for design work"

Answer: "I can help you request Figma Professional ($144/year). Based on your role as Product Manager, this typically requires your manager's approval (Sarah Chen) and IT approval, taking 2-3 business days. The approval rate for Design team members is 94%. I've pre-filled a business justification based on your role. Would you like to submit the request?"

Q3: How much does this software cost the company?

Why it matters: Users want to understand the cost of tools they're requesting or using, helping them make informed decisions and appreciate the investment in their productivity.

Telemetry Sources

Source	Data Retrieved	API Endpoint	Refresh Frequency
Procurement	License costs, seat pricing	Procurement system API	Daily
Service Catalog	Published pricing (may be estimated)	Service catalog API	Daily
Finance	Actual spend per application	Finance system API	Monthly

L1 Analytics (Bronze→Silver)

-- Calculate user-facing cost information
CREATE TABLE silver.user_visible_costs AS
SELECT
    sp.software_product_id,
    sp.software_name,
    sp.vendor_name,
    sp.category,
    -- Licensing costs
    sl.license_type,
    sl.unit_cost as cost_per_license,
    sl.billing_frequency, -- 'monthly', 'annual', 'perpetual'
    -- Normalized annual cost
    CASE
        WHEN sl.billing_frequency = 'monthly' THEN sl.unit_cost * 12
        WHEN sl.billing_frequency = 'annual' THEN sl.unit_cost
        WHEN sl.billing_frequency = 'perpetual' THEN sl.unit_cost / 5 -- Amortize over 5 years
    END as annual_cost_per_user,
    -- Company-wide investment
    sl.quantity as total_licenses,
    sl.total_cost as total_annual_cost,
    -- Visibility controls
    sp.cost_visible_to_users, -- Some orgs hide costs
    CASE
        WHEN sp.cost_visible_to_users = TRUE THEN 'visible'
        ELSE 'contact_it'
    END as cost_display_mode
FROM silver.software_product sp
JOIN silver.software_license sl ON sp.software_product_id = sl.software_product_id;

Transformations:

Normalize costs to annual per-user basis
Apply visibility rules (some orgs hide costs from users)
Round to user-friendly numbers
Include total company investment context

L2 Analytics (Silver→Gold)

-- Aggregate cost context for user decision-making
CREATE TABLE gold.user_cost_context AS
SELECT
    uvc.software_product_id,
    uvc.software_name,
    uvc.vendor_name,
    uvc.annual_cost_per_user,
    uvc.total_annual_cost,
    uvc.total_licenses,
    -- Usage context
    COUNT(DISTINCT la.pii_id) as assigned_users,
    COUNT(DISTINCT CASE WHEN lua.usage_classification IN ('power_user', 'regular_user') THEN la.pii_id END) as active_users,
    -- Cost per active user
    uvc.total_annual_cost / NULLIF(COUNT(DISTINCT CASE WHEN lua.usage_classification IN ('power_user', 'regular_user') THEN la.pii_id END), 0) as cost_per_active_user,
    -- Comparative context
    AVG(uvc.annual_cost_per_user) OVER (PARTITION BY uvc.category) as avg_cost_in_category,
    CASE
        WHEN uvc.annual_cost_per_user > AVG(uvc.annual_cost_per_user) OVER (PARTITION BY uvc.category) * 1.5 THEN 'premium'
        WHEN uvc.annual_cost_per_user > AVG(uvc.annual_cost_per_user) OVER (PARTITION BY uvc.category) THEN 'above_average'
        ELSE 'standard'
    END as cost_tier
FROM silver.user_visible_costs uvc
LEFT JOIN silver.license_assignment la ON uvc.software_product_id = la.software_product_id
LEFT JOIN gold.license_usage_analytics lua ON la.software_license_id = lua.software_license_id AND la.pii_id = lua.pii_id
GROUP BY uvc.software_product_id, uvc.software_name, uvc.vendor_name, uvc.annual_cost_per_user, uvc.total_annual_cost, uvc.total_licenses;

Metrics Calculated:

Cost per user (monthly/annual)
Total company investment
Cost tier (standard, above average, premium)
Comparative context within category
Total users with access

Cerebro Enhancement

Intelligence: Contextualize cost relative to similar tools
Intelligence: Highlight company's investment in user's productivity
Reasoning: Suggest cost-effective alternatives when appropriate
Reasoning: Explain value proposition relative to cost

UI Representation

Component: Copilot conversational cost transparency

Visualization:

┌─────────────────────────────────────────────────────────────┐
│ 💬 Copilot                                                  │
├─────────────────────────────────────────────────────────────┤
│ You: How much does Adobe Creative Cloud cost?              │
│                                                             │
│ 🤖 Copilot: Adobe Creative Cloud costs the company:        │
│                                                             │
│    💰 $52.99/month per user ($636/year)                     │
│    📊 Total company investment: $288,000/year               │
│    👥 Licensed to: 452 employees                            │
│                                                             │
│    This is a premium design tool. For context:              │
│    • Average design tool: ~$400/year                        │
│    • Adobe CC includes: Photoshop, Illustrator, InDesign,  │
│      Premiere Pro, After Effects, and 15+ more apps        │
│                                                             │
│    ✓ You currently have access to Adobe CC                 │
│                                                             │
│    💡 The company invests in premium tools like this to     │
│       ensure you have professional-grade design software.   │
│                                                             │
│ [View My Software] [Learn More] [Request Different Tool]   │
└─────────────────────────────────────────────────────────────┘

Interactions:

Natural language query: "How much does X cost?"
Copilot explains per-user and total costs
Provides context (premium vs. standard)
Highlights value and capabilities
Option to request alternatives if needed

Copilot Query Example:

"How much does Figma cost the company?"

Answer: "Figma Professional costs $12/month per user ($144/year). The company currently licenses it for 85 employees with a total annual investment of $12,240. This is a standard-priced design collaboration tool. Figma is popular in the design and product teams for real-time collaboration on UI/UX projects."

Q4: When was my software licensed?

Why it matters: Users want to understand when they received access, how long they've had tools, and when licenses might expire or need renewal.

Telemetry Sources

Source	Data Retrieved	API Endpoint	Refresh Frequency
IDP	Assignment date, last modified	`/users/{id}/appRoleAssignments`	Real-time
Service Desk	Fulfillment date from request	ServiceNow `/table/sc_request`	Real-time
UEM	Installation date on devices	Device telemetry API	Hourly
Audit Logs	License assignment events	`/auditLogs/directoryAudits`	Real-time

L1 Analytics (Bronze→Silver)

-- Track user license lifecycle dates
CREATE TABLE silver.user_license_timeline AS
SELECT
    la.license_assignment_id,
    la.pii_id,
    u.display_name,
    la.software_product_id,
    sp.software_name,
    -- Timeline dates
    sr.request_date,
    sr.approval_date,
    la.assignment_date,
    la.first_login_date,
    la.last_login_date,
    sl.end_date as license_expiry_date,
    -- Tenure
    DATEDIFF(CURRENT_DATE, la.assignment_date) as days_since_assigned,
    DATEDIFF(la.first_login_date, la.assignment_date) as days_to_first_use,
    DATEDIFF(CURRENT_DATE, la.last_login_date) as days_since_last_use,
    -- Status
    la.assignment_status,
    CASE
        WHEN sl.end_date < CURRENT_DATE THEN 'expired'
        WHEN sl.end_date BETWEEN CURRENT_DATE AND CURRENT_DATE + INTERVAL '30 days' THEN 'expiring_soon'
        ELSE 'active'
    END as license_status
FROM silver.license_assignment la
JOIN silver.user_directory u ON la.pii_id = u.pii_id
JOIN silver.software_product sp ON la.software_product_id = sp.software_product_id
LEFT JOIN silver.software_license sl ON la.software_license_id = sl.software_license_id
LEFT JOIN silver.software_requests sr ON la.pii_id = sr.requestor_pii_id AND la.software_product_id = sr.software_product_id;

Transformations:

Link assignment to original request (if applicable)
Calculate tenure (how long user has had access)
Identify first use vs. assignment date
Flag expiring licenses

L2 Analytics (Silver→Gold)

-- Aggregate user license history
CREATE TABLE gold.user_license_history AS
SELECT
    ult.pii_id,
    ult.display_name,
    ult.software_product_id,
    ult.software_name,
    -- Key dates
    ult.assignment_date,
    ult.first_login_date,
    ult.last_login_date,
    ult.license_expiry_date,
    -- Tenure metrics
    ult.days_since_assigned,
    FLOOR(ult.days_since_assigned / 365.0) as years_with_access,
    FLOOR(MOD(ult.days_since_assigned, 365) / 30.0) as additional_months_with_access,
    -- Usage pattern
    CASE
        WHEN ult.first_login_date IS NULL THEN 'never_used'
        WHEN ult.days_to_first_use > 30 THEN 'slow_adoption'
        ELSE 'immediate_use'
    END as adoption_pattern,
    CASE
        WHEN ult.days_since_last_use <= 7 THEN 'active_this_week'
        WHEN ult.days_since_last_use <= 30 THEN 'active_this_month'
        WHEN ult.days_since_last_use <= 90 THEN 'active_this_quarter'
        ELSE 'inactive'
    END as recent_usage,
    -- Expiry awareness
    ult.license_status,
    CASE
        WHEN ult.license_status = 'expiring_soon' THEN DATEDIFF(ult.license_expiry_date, CURRENT_DATE)
    END as days_until_expiry
FROM silver.user_license_timeline ult;

Metrics Calculated:

Assignment date (when access was granted)
First login date (when user first used it)
License expiry date (if applicable)
Tenure (years/months with access)
Recent activity status
Days until expiry (if expiring soon)

Cerebro Enhancement

Memory: Track user's complete license history across role changes
Intelligence: Detect unused licenses assigned long ago
Intelligence: Alert users of expiring licenses before they lose access
Reasoning: Suggest renewal if license expiring and actively used

UI Representation

Component: Copilot conversational timeline with "My Software Timeline" view

Visualization:

┌─────────────────────────────────────────────────────────────┐
│ 💬 Copilot                                                  │
├─────────────────────────────────────────────────────────────┤
│ You: When was I given access to Adobe Creative Cloud?      │
│                                                             │
│ 🤖 Copilot: Your Adobe Creative Cloud license history:     │
│                                                             │
│    📅 Granted: March 15, 2022 (2 years, 10 months ago)     │
│    🚀 First use: March 18, 2022 (3 days after assignment)  │
│    📊 Last used: Today                                      │
│    ⏰ Expires: March 15, 2025 (59 days remaining)           │
│                                                             │
│    ⚠️  Your license expires in 59 days. IT will            │
│       automatically renew active licenses 30 days before    │
│       expiry. No action needed on your part.                │
│                                                             │
│    💡 You've been actively using Adobe CC for almost       │
│       3 years - great utilization!                          │
│                                                             │
│ [View All My Software] [Usage History] [Contact IT]        │
└─────────────────────────────────────────────────────────────┘

Interactions:

Natural language query: "When did I get access to X?"
Shows complete timeline (granted → first use → last use → expiry)
Alerts if license expiring soon
Explains renewal process
Links to usage history

Copilot Query Example:

"When was my Figma license granted?"

Answer: "You were granted access to Figma Professional on June 10, 2024 (7 months ago). You first used it on June 12, 2024, and you last logged in yesterday. Your license is part of the company's annual subscription and will renew automatically on March 1, 2025. No action needed from you."

Q5: Who approved my software access?

Why it matters: Users want transparency into approval workflows, understand who supported their request, and know who to contact for future software needs.

Telemetry Sources

Source	Data Retrieved	API Endpoint	Refresh Frequency
Service Desk	Approval workflow, approvers	ServiceNow `/table/sysapproval_approver`	Real-time
IDP	User directory for approver details	SCIM `/Users`	Daily
Audit Logs	Approval actions and timestamps	`/auditLogs/directoryAudits`	Real-time

L1 Analytics (Bronze→Silver)

-- Track approval workflow for user requests
CREATE TABLE silver.user_software_approvals AS
SELECT
    sr.request_id,
    sr.requestor_pii_id,
    req.display_name as requestor_name,
    sr.software_product_id,
    sp.software_name,
    sr.request_date,
    -- Approval chain
    sa.approver_pii_id,
    app.display_name as approver_name,
    app.email as approver_email,
    app.job_title as approver_title,
    app.department_name as approver_department,
    sa.approval_level, -- 1 = manager, 2 = IT, 3 = procurement, etc.
    sa.approval_stage, -- 'manager_approval', 'it_approval', 'security_review'
    sa.approval_status, -- 'approved', 'rejected', 'pending'
    sa.approval_date,
    sa.approval_comments,
    -- Relationship to requestor
    CASE
        WHEN app.pii_id = req.manager_pii_id THEN 'direct_manager'
        WHEN app.department_name = 'IT' THEN 'it_team'
        WHEN app.department_name = 'Procurement' THEN 'procurement_team'
        WHEN app.department_name = 'Security' THEN 'security_team'
        ELSE 'other'
    END as approver_type
FROM silver.software_requests sr
JOIN silver.user_directory req ON sr.requestor_pii_id = req.pii_id
JOIN silver.software_product sp ON sr.software_product_id = sp.software_product_id
LEFT JOIN bronze.service_approval sa ON sr.request_id = sa.request_id
LEFT JOIN silver.user_directory app ON sa.approver_pii_id = app.pii_id
WHERE sr.request_status IN ('approved', 'provisioned');

Transformations:

Resolve approver identities and roles
Identify approval chain (manager → IT → procurement)
Track approval timeline per stage
Classify approver relationship to user

L2 Analytics (Silver→Gold)

-- Aggregate approval patterns for user context
CREATE TABLE gold.user_approval_summary AS
SELECT
    usa.requestor_pii_id,
    usa.software_product_id,
    usa.software_name,
    usa.request_date,
    -- Approval summary
    COUNT(DISTINCT usa.approver_pii_id) as total_approvers,
    STRING_AGG(usa.approver_name, ' → ' ORDER BY usa.approval_level) as approval_chain,
    STRING_AGG(usa.approver_type, ' → ' ORDER BY usa.approval_level) as approval_path,
    MIN(usa.approval_date) as first_approval_date,
    MAX(usa.approval_date) as final_approval_date,
    DATEDIFF(MAX(usa.approval_date), usa.request_date) as total_approval_time_days,
    -- Primary approver (usually direct manager)
    MAX(CASE WHEN usa.approval_level = 1 THEN usa.approver_name END) as primary_approver,
    MAX(CASE WHEN usa.approval_level = 1 THEN usa.approver_email END) as primary_approver_email
FROM silver.user_software_approvals usa
GROUP BY usa.requestor_pii_id, usa.software_product_id, usa.software_name, usa.request_date;

Metrics Calculated:

Complete approval chain (all approvers in sequence)
Primary approver (usually manager)
Approval timeline (request → final approval)
Number of approval stages
Approver roles (manager, IT, procurement, security)

Cerebro Enhancement

Memory: Track which approvers typically support which types of requests
Intelligence: Identify user's primary software champion (approves most requests)
Reasoning: Suggest which approver to contact for expedited requests

UI Representation

Component: Copilot conversational approval history

Visualization:

┌─────────────────────────────────────────────────────────────┐
│ 💬 Copilot                                                  │
├─────────────────────────────────────────────────────────────┤
│ You: Who approved my Figma access?                         │
│                                                             │
│ 🤖 Copilot: Your Figma Professional access was approved by:│
│                                                             │
│    📋 Request Date: June 10, 2024                           │
│                                                             │
│    ✅ Approval Chain:                                       │
│       1. Sarah Chen (Your Manager)                          │
│          • Approved: June 10, 2024 (same day)              │
│          • Role: Product Design Manager                     │
│          • Email: [email protected]                    │
│                                                             │
│       2. IT Team (Kevin Park)                               │
│          • Approved: June 11, 2024 (next day)              │
│          • Role: IT Systems Administrator                   │
│          • Email: [email protected]                   │
│                                                             │
│    ⏱️  Total approval time: 2 days                         │
│    ✓ Provisioned: June 12, 2024                            │
│                                                             │
│    💡 Sarah Chen has approved 4 of your software requests  │
│       in the past year - she's your primary software        │
│       champion for future requests.                         │
│                                                             │
│ [View All Approvals] [Request New Software] [Thank Sarah]  │
└─────────────────────────────────────────────────────────────┘

Interactions:

Natural language query: "Who approved my X access?"
Shows complete approval chain with names, roles, emails
Timeline of approval stages
Identifies primary software champion
Option to thank approvers or contact for future requests

Copilot Query Example:

"Who approved my Adobe Creative Cloud license?"

Answer: "Your Adobe Creative Cloud access was approved by: 1) Sarah Chen (your manager) on March 15, 2022, and 2) IT Team (Kevin Park) on March 15, 2022. Both approvals came in on the same day, and you were provisioned on March 15, 2022. Sarah has been your primary software approver, supporting 6 of your software requests."

Q6: Can I switch to a different software tool?

Why it matters: Users need flexibility to try alternative tools if current software doesn't meet their needs, while understanding the process and impact.

Telemetry Sources

Source	Data Retrieved	API Endpoint	Refresh Frequency
Service Catalog	Available alternatives, capabilities	Service catalog API	Daily
IDP	Current entitlements	`/users/{id}/appRoleAssignments`	Real-time
Procurement	Existing licenses, seat availability	Procurement system API	Hourly
Usage Analytics	Usage patterns, feature utilization	Usage telemetry API	Daily

L1 Analytics (Bronze→Silver)

-- Map software alternatives and switching feasibility
CREATE TABLE silver.software_alternatives AS
SELECT
    sp.software_product_id as current_software_id,
    sp.software_name as current_software_name,
    sp.category,
    -- Alternative products
    alt.software_product_id as alternative_software_id,
    alt.software_name as alternative_software_name,
    alt.vendor_name as alternative_vendor,
    -- Comparison
    rel.relationship_type, -- 'direct_alternative', 'upgrade', 'downgrade', 'complementary'
    rel.feature_overlap_pct,
    rel.migration_complexity, -- 'easy', 'moderate', 'complex'
    -- Availability
    CASE
        WHEN alt_lic.available_seats > 0 THEN TRUE
        ELSE FALSE
    END as seats_available,
    alt_lic.available_seats,
    alt_lic.unit_cost as alternative_cost,
    sp.unit_cost as current_cost,
    -- Switching policy
    pol.switch_allowed,
    pol.approval_required,
    pol.trial_period_days
FROM silver.software_product sp
JOIN silver.software_relationship rel ON sp.software_product_id = rel.software_product_id
JOIN silver.software_product alt ON rel.related_software_product_id = alt.software_product_id
LEFT JOIN silver.software_license alt_lic ON alt.software_product_id = alt_lic.software_product_id
LEFT JOIN silver.software_policy pol ON sp.software_product_id = pol.software_product_id
WHERE rel.relationship_type IN ('direct_alternative', 'upgrade', 'downgrade');

Transformations:

Identify approved alternatives by category
Check seat availability in existing licenses
Calculate cost implications
Assess migration complexity
Apply company switching policies

L2 Analytics (Silver→Gold)

-- Aggregate switching options for user decision-making
CREATE TABLE gold.user_switching_options AS
SELECT
    sa.current_software_id,
    sa.current_software_name,
    sa.category,
    -- Alternatives summary
    COUNT(DISTINCT sa.alternative_software_id) as available_alternatives,
    COUNT(DISTINCT CASE WHEN sa.seats_available = TRUE THEN sa.alternative_software_id END) as alternatives_with_seats,
    COUNT(DISTINCT CASE WHEN sa.relationship_type = 'upgrade' THEN sa.alternative_software_id END) as upgrade_options,
    COUNT(DISTINCT CASE WHEN sa.relationship_type = 'downgrade' THEN sa.alternative_software_id END) as downgrade_options,
    -- Switching friction
    MODE(sa.migration_complexity) as typical_migration_complexity,
    MODE(sa.approval_required) as typically_requires_approval,
    -- Cost impact
    AVG(sa.alternative_cost - sa.current_cost) as avg_cost_difference
FROM silver.software_alternatives sa
GROUP BY sa.current_software_id, sa.current_software_name, sa.category;

Metrics Calculated:

Available alternatives in same category
Seat availability in alternative licenses
Cost implications (more/less expensive)
Migration complexity (data transfer, training)
Approval requirements for switching
Trial period availability

Cerebro Enhancement

Memory: Track user's previous software preferences and switches
Intelligence: Recommend best alternative based on user's role and usage patterns
Intelligence: Predict switching success based on peer migrations
Reasoning: Suggest trial period before permanent switch
Reasoning: Highlight data migration considerations

UI Representation

Component: Copilot-guided software comparison and switching workflow

Visualization:

┌─────────────────────────────────────────────────────────────┐
│ 💬 Copilot                                                  │
├─────────────────────────────────────────────────────────────┤
│ You: Can I switch from Miro to Figma?                      │
│                                                             │
│ 🤖 Copilot: Yes, you can switch! Here's what you need to   │
│    know:                                                    │
│                                                             │
│    📊 Current: Miro (Whiteboarding)                        │
│    🎯 Alternative: Figma (Design/Prototyping)              │
│                                                             │
│    ✓ Seat available: Yes (85 licenses, 12 open seats)      │
│    💰 Cost impact: +$96/year ($144 vs. $48)                │
│    ⏱️  Migration: Easy (projects can be exported/imported) │
│    👥 Approval needed: Yes (Manager + IT)                   │
│                                                             │
│    💡 Differences:                                          │
│    • Miro: Best for brainstorming and workshops            │
│    • Figma: Best for UI/UX design and prototyping          │
│    • Can you use both? Yes, they complement each other     │
│                                                             │
│    📋 Next Steps:                                           │
│    1. Try Figma free trial (14 days) before switching      │
│    2. Export your Miro boards (I can guide you)            │
│    3. Request Figma access (typical approval: 2-3 days)    │
│    4. Optionally keep Miro if you use it for different     │
│       purposes                                              │
│                                                             │
│ [Start Figma Trial] [Request Switch] [Compare Features]    │
└─────────────────────────────────────────────────────────────┘

Interactions:

Natural language query: "Can I switch from X to Y?"
Copilot explains switching process and implications
Shows cost difference and migration complexity
Offers trial period before commitment
Option to keep both if they serve different purposes
Guides through data migration

Copilot Query Example:

"Can I switch to a different project management tool?"

Answer: "You're currently using Asana. Here are approved alternatives: 1) Jira (for engineering teams), 2) Monday.com (for marketing teams), 3) Trello (simpler alternative). Switching requires manager approval. I recommend trying a 14-day trial first. Which type of work do you primarily manage? I can recommend the best fit based on your needs."

Q7: Who can I ask about software capabilities?

Why it matters: Users need to know who can help them learn software features, troubleshoot issues, or provide training and best practices.

Telemetry Sources

Source	Data Retrieved	API Endpoint	Refresh Frequency
IDP	Technical admins, power users	User directory with roles	Daily
Service Desk	Support ticket routing, resolver groups	ServiceNow `/table/sys_user_group`	Daily
Usage Analytics	Power users (high usage, advanced features)	Usage telemetry API	Daily
Knowledge Base	Documentation owners, SMEs	KB article metadata	Daily

L1 Analytics (Bronze→Silver)

-- Identify software experts and support contacts
CREATE TABLE silver.software_support_contacts AS
SELECT
    sp.software_product_id,
    sp.software_name,
    sp.vendor_name,
    sp.category,
    -- Technical owner/admin
    so.technical_owner_pii_id,
    tech.display_name as technical_owner_name,
    tech.email as technical_owner_email,
    tech.job_title as technical_owner_title,
    -- Power users (usage-based experts)
    lua.pii_id as power_user_pii_id,
    pu.display_name as power_user_name,
    pu.email as power_user_email,
    pu.department_name as power_user_department,
    lua.days_used_last_90,
    lua.unique_features_used,
    -- Support team
    sg.support_group_name,
    sg.support_email,
    sg.support_slack_channel,
    -- Vendor resources
    sp.vendor_support_url,
    sp.internal_documentation_url,
    sp.training_resources_url
FROM silver.software_product sp
LEFT JOIN silver.software_ownership so ON sp.software_product_id = so.software_product_id
LEFT JOIN silver.user_directory tech ON so.technical_owner_pii_id = tech.pii_id
LEFT JOIN gold.license_usage_analytics lua ON sp.software_product_id = lua.software_product_id
LEFT JOIN silver.user_directory pu ON lua.pii_id = pu.pii_id
LEFT JOIN silver.support_group sg ON sp.software_product_id = sg.software_product_id
WHERE lua.usage_classification = 'power_user'
ORDER BY lua.days_used_last_90 DESC, lua.unique_features_used DESC
LIMIT 5 PER sp.software_product_id; -- Top 5 power users per product

Transformations:

Identify official technical owners/admins
Find power users based on usage intensity and feature adoption
Map to support groups and resolver queues
Include self-service resources (docs, training, vendor support)

L2 Analytics (Silver→Gold)

-- Aggregate support ecosystem per software
CREATE TABLE gold.software_support_ecosystem AS
SELECT
    ssc.software_product_id,
    ssc.software_name,
    ssc.vendor_name,
    -- Official support
    MAX(ssc.technical_owner_name) as primary_technical_owner,
    MAX(ssc.technical_owner_email) as technical_owner_email,
    MAX(ssc.support_group_name) as official_support_team,
    MAX(ssc.support_email) as support_email,
    MAX(ssc.support_slack_channel) as support_slack_channel,
    -- Power user community
    COUNT(DISTINCT ssc.power_user_pii_id) as identified_power_users,
    STRING_AGG(ssc.power_user_name, ', ' ORDER BY ssc.days_used_last_90 DESC) as top_power_users,
    -- Self-service resources
    MAX(ssc.vendor_support_url) as vendor_documentation,
    MAX(ssc.internal_documentation_url) as internal_wiki,
    MAX(ssc.training_resources_url) as training_portal,
    -- Support metrics
    AVG(st.avg_resolution_time_hours) as avg_support_ticket_resolution_hours,
    AVG(st.user_satisfaction_score) as support_satisfaction_score
FROM silver.software_support_contacts ssc
LEFT JOIN gold.support_ticket_metrics st ON ssc.software_product_id = st.software_product_id
GROUP BY ssc.software_product_id, ssc.software_name, ssc.vendor_name;

Metrics Calculated:

Technical owner/administrator
Power users in user's department
Official support team contacts
Support channels (email, Slack, portal)
Average response/resolution times
Self-service resources available

Cerebro Enhancement

Memory: Track which experts helped user in the past
Intelligence: Match user to nearby power users (same department/location)
Intelligence: Route questions to appropriate expert based on query type
Reasoning: Suggest self-service first, then power users, then official support
Reasoning: Recommend relevant training resources based on user's skill level

UI Representation

Component: Copilot conversational expert finder

Visualization:

┌─────────────────────────────────────────────────────────────┐
│ 💬 Copilot                                                  │
├─────────────────────────────────────────────────────────────┤
│ You: Who can help me with advanced Figma features?         │
│                                                             │
│ 🤖 Copilot: Here's who can help with Figma:                │
│                                                             │
│    🔧 Technical Admin                                       │
│    • Kevin Park (IT Systems Administrator)                  │
│    • Email: [email protected]                          │
│    • Best for: Access issues, license questions            │
│                                                             │
│    ⭐ Power Users in Your Department (Design)               │
│    • Lisa Chen (Senior Product Designer)                    │
│      └─ Expert in: Prototyping, Auto Layout, Components    │
│      └─ Slack: @lisa.chen                                   │
│    • Marcus Johnson (Lead UX Designer)                      │
│      └─ Expert in: Design systems, Variables, Plugins      │
│      └─ Slack: @marcus.j                                    │
│                                                             │
│    💬 Support Channels                                      │
│    • Slack: #design-tools-help                              │
│    • Email: [email protected]                      │
│    • Avg response time: 4 hours                             │
│                                                             │
│    📚 Learning Resources                                    │
│    • Internal Wiki: company.com/wiki/figma                  │
│    • Figma Training: figma.com/resources/learn              │
│    • Video Tutorials: company.learning/figma-advanced       │
│                                                             │
│    💡 Lisa Chen is in your office and has helped 12 other  │
│       designers - she's a great resource!                   │
│                                                             │
│ [Contact Lisa] [Join #design-tools-help] [View Resources]  │
└─────────────────────────────────────────────────────────────┘

Interactions:

Natural language query: "Who can help me with X?"
Copilot identifies technical owners, power users, and support channels
Prioritizes experts in user's department or location
Provides contact methods (email, Slack, in-person)
Links to self-service resources
Shows support metrics (response times, satisfaction)

Copilot Query Example:

"Who can I ask about Salesforce reporting?"

Answer: "For Salesforce reporting help: 1) Robert Chen (VP Revenue Operations) is the technical owner, 2) Power users in Sales: Jennifer Martinez (expert in custom reports) and Tom Wilson (expert in dashboards), 3) Join #salesforce-help on Slack (avg response: 2 hours), 4) Check the internal Salesforce wiki at company.com/wiki/salesforce-reports. Jennifer is in your building and has helped 8 people this month!"

Q8: Why don't I have access to specific software?

Why it matters: Users experience frustration when they can't access software they need or expect to have. Understanding why helps them take appropriate action.

Telemetry Sources

Source	Data Retrieved	API Endpoint	Refresh Frequency
IDP	Entitlements, group memberships, access policies	`/users/{id}/appRoleAssignments`	Real-time
Service Desk	Previous requests, rejection history	ServiceNow `/table/sc_request`	Real-time
Service Catalog	Software availability, restrictions	Service catalog API	Daily
Procurement	License inventory, seat availability	Procurement system API	Hourly

L1 Analytics (Bronze→Silver)

-- Analyze access gaps and reasons
CREATE TABLE silver.software_access_gaps AS
SELECT
    u.pii_id,
    u.display_name,
    u.email,
    u.department_name,
    u.job_title,
    sp.software_product_id,
    sp.software_name,
    sp.vendor_name,
    -- Access status
    CASE
        WHEN la.license_assignment_id IS NOT NULL THEN 'has_access'
        ELSE 'no_access'
    END as access_status,
    -- Reasons for no access
    CASE
        WHEN sl.available_seats = 0 THEN 'no_seats_available'
        WHEN sr.request_id IS NOT NULL AND sr.request_status = 'rejected' THEN 'request_rejected'
        WHEN sr.request_id IS NOT NULL AND sr.request_status = 'pending_approval' THEN 'pending_approval'
        WHEN ap.restricted_to_departments NOT LIKE '%' || u.department_name || '%' THEN 'department_restriction'
        WHEN ap.restricted_to_job_roles NOT LIKE '%' || u.job_title || '%' THEN 'role_restriction'
        WHEN ap.requires_security_clearance = TRUE AND u.security_clearance_level < ap.required_clearance_level THEN 'security_restriction'
        WHEN sr.request_id IS NULL THEN 'never_requested'
        ELSE 'other'
    END as access_gap_reason,
    -- Context
    sl.available_seats,
    sl.total_licenses,
    sr.rejection_reason,
    sr.request_date as last_request_date,
    ap.policy_description,
    -- Peer access
    COUNT(DISTINCT peer_la.pii_id) as peers_with_access,
    COUNT(DISTINCT peer_u.pii_id) as total_peers
FROM silver.user_directory u
CROSS JOIN silver.software_product sp
LEFT JOIN silver.license_assignment la ON u.pii_id = la.pii_id AND sp.software_product_id = la.software_product_id
LEFT JOIN silver.software_license sl ON sp.software_product_id = sl.software_product_id
LEFT JOIN silver.software_requests sr ON u.pii_id = sr.requestor_pii_id AND sp.software_product_id = sr.software_product_id
LEFT JOIN silver.access_policy ap ON sp.software_product_id = ap.software_product_id
-- Peer comparison
LEFT JOIN silver.user_directory peer_u ON u.department_name = peer_u.department_name AND u.pii_id != peer_u.pii_id
LEFT JOIN silver.license_assignment peer_la ON peer_u.pii_id = peer_la.pii_id AND sp.software_product_id = peer_la.software_product_id
WHERE la.license_assignment_id IS NULL -- User does NOT have access
GROUP BY u.pii_id, sp.software_product_id, /* ... all other columns ... */;

Transformations:

Identify why user lacks access (no seats, rejected, restricted, never requested)
Check previous request history
Compare to peer access in same department
Apply access policies and restrictions

L2 Analytics (Silver→Gold)

-- Aggregate access guidance and recommendations
CREATE TABLE gold.access_gap_resolution AS
SELECT
    sag.pii_id,
    sag.software_product_id,
    sag.software_name,
    sag.access_gap_reason,
    -- Actionable guidance
    CASE
        WHEN sag.access_gap_reason = 'no_seats_available' THEN 'Additional licenses needed - IT is reviewing requests'
        WHEN sag.access_gap_reason = 'request_rejected' THEN 'Previous request rejected: ' || sag.rejection_reason
        WHEN sag.access_gap_reason = 'pending_approval' THEN 'Your request is pending approval (submitted ' || TO_CHAR(sag.last_request_date, 'MM/DD/YYYY') || ')'
        WHEN sag.access_gap_reason = 'department_restriction' THEN 'This software is restricted to specific departments: ' || ap.restricted_to_departments
        WHEN sag.access_gap_reason = 'role_restriction' THEN 'This software is restricted to specific roles: ' || ap.restricted_to_job_roles
        WHEN sag.access_gap_reason = 'security_restriction' THEN 'This software requires security clearance level ' || ap.required_clearance_level
        WHEN sag.access_gap_reason = 'never_requested' THEN 'You have not requested access. Would you like to submit a request?'
        ELSE 'Contact IT for assistance: [email protected]'
    END as guidance_message,
    -- Alternative suggestions
    COUNT(DISTINCT alt.alternative_software_id) as available_alternatives,
    STRING_AGG(alt.alternative_software_name, ', ') as alternative_software_names,
    -- Peer context
    sag.peers_with_access,
    sag.total_peers,
    sag.peers_with_access::FLOAT / NULLIF(sag.total_peers, 0) * 100 as pct_peers_with_access
FROM silver.software_access_gaps sag
LEFT JOIN silver.software_alternatives alt ON sag.software_product_id = alt.current_software_id AND alt.seats_available = TRUE
LEFT JOIN silver.access_policy ap ON sag.software_product_id = ap.software_product_id
GROUP BY sag.pii_id, sag.software_product_id, sag.software_name, sag.access_gap_reason, /* other fields */;

Metrics Calculated:

Reason for no access (clear, actionable explanation)
Previous request history
Access restrictions (department, role, security)
Seat availability status
Alternative software options
Peer access rates (how many colleagues have it)

Cerebro Enhancement

Memory: Track user's request history and patterns
Intelligence: Predict likelihood of approval if they request
Intelligence: Suggest best time to request (when seats become available)
Reasoning: Recommend alternatives if access unlikely
Reasoning: Pre-fill strong business justification if previous request rejected

UI Representation

Component: Copilot conversational access diagnostics

Visualization:

┌─────────────────────────────────────────────────────────────┐
│ 💬 Copilot                                                  │
├─────────────────────────────────────────────────────────────┤
│ You: Why don't I have access to Adobe Premiere Pro?        │
│                                                             │
│ 🤖 Copilot: You don't currently have Adobe Premiere Pro    │
│    because:                                                 │
│                                                             │
│    ❌ Reason: No available seats                            │
│                                                             │
│    📊 Status:                                               │
│    • Total licenses: 25                                     │
│    • Assigned: 25 (100%)                                    │
│    • Waitlist: 8 pending requests (you're not on it yet)   │
│                                                             │
│    💡 Background:                                           │
│    Premiere Pro is currently at full capacity. IT reviews   │
│    utilization quarterly and may purchase additional        │
│    licenses. The next review is February 2025.              │
│                                                             │
│    🎯 Your Options:                                         │
│    1. Join the waitlist (typically 30-45 days)              │
│    2. Use DaVinci Resolve (free alternative, 12 seats open) │
│    3. Request temporary access (project-based, up to 90d)   │
│                                                             │
│    👥 Context: 6 of your Marketing colleagues have Premiere │
│       Pro. 85% of the Design team uses it actively.         │
│                                                             │
│    What would you like to do?                               │
│                                                             │
│ [Join Waitlist] [Try DaVinci Resolve] [Request Temp Access]│
└─────────────────────────────────────────────────────────────┘

Interactions:

Natural language query: "Why don't I have X?"
Copilot explains specific reason (clear, non-technical)
Shows context (seat availability, waitlist, restrictions)
Provides actionable options (request, waitlist, alternatives)
Compares to peer access rates
Guides next steps

Copilot Query Example:

"Why can't I access Salesforce?"

Answer: "You don't have Salesforce access because it's restricted to Sales and Customer Success teams. Your role (Product Manager, Engineering) is not included in the approved access policy. However, 3 product managers in the Product Management department do have access. If you need Salesforce for cross-functional work, you can request an exception with strong business justification. Alternatively, you can request read-only access for reporting purposes."

Q9: How do I report a software issue?

Why it matters: Users need a fast, easy way to report bugs, access problems, or request support without navigating complex IT ticketing systems.

Telemetry Sources

Source	Data Retrieved	API Endpoint	Refresh Frequency
Service Desk	Incident tickets, resolver groups, SLAs	ServiceNow `/table/incident`	Real-time
UEM	Device diagnostics, error logs	Device telemetry API	Real-time
IDP	User identity, entitlements	SCIM `/Users`	Real-time
Knowledge Base	Known issues, self-service solutions	KB API	Daily

L1 Analytics (Bronze→Silver)

-- Normalize incident reporting workflow
CREATE TABLE silver.software_incidents AS
SELECT
    inc.incident_id,
    inc.reporter_pii_id,
    u.display_name as reporter_name,
    u.email as reporter_email,
    inc.software_product_id,
    sp.software_name,
    sp.vendor_name,
    -- Incident details
    inc.incident_type, -- 'access_issue', 'bug', 'performance', 'feature_request', 'training_request'
    inc.severity, -- 'critical', 'high', 'medium', 'low'
    inc.description,
    inc.reported_date,
    inc.incident_status, -- 'new', 'assigned', 'in_progress', 'resolved', 'closed'
    -- Resolution tracking
    inc.assigned_to_group,
    inc.assigned_to_pii_id,
    inc.resolution_date,
    inc.resolution_notes,
    DATEDIFF(inc.resolution_date, inc.reported_date) as resolution_time_hours / 24.0 as resolution_time_days,
    inc.user_satisfaction_score, -- 1-5 rating
    -- Diagnostics
    inc.error_code,
    inc.device_id,
    dev.device_type,
    dev.os_version
FROM bronze.service_incident inc
JOIN silver.user_directory u ON inc.reporter_pii_id = u.pii_id
LEFT JOIN silver.software_product sp ON inc.software_product_id = sp.software_product_id
LEFT JOIN silver.device dev ON inc.device_id = dev.device_id
WHERE inc.incident_category = 'software';

Transformations:

Classify incident type (access, bug, performance, training)
Link to software product and user entitlements
Track resolution workflow and SLAs
Capture device diagnostics automatically

L2 Analytics (Silver→Gold)

-- Aggregate support metrics and known issues
CREATE TABLE gold.software_support_metrics AS
SELECT
    si.software_product_id,
    sp.software_name,
    sp.vendor_name,
    -- Incident volume
    COUNT(DISTINCT si.incident_id) as total_incidents_last_30_days,
    COUNT(DISTINCT si.reporter_pii_id) as unique_reporters,
    COUNT(DISTINCT CASE WHEN si.incident_status IN ('new', 'assigned', 'in_progress') THEN si.incident_id END) as open_incidents,
    -- By type
    COUNT(DISTINCT CASE WHEN si.incident_type = 'access_issue' THEN si.incident_id END) as access_issues,
    COUNT(DISTINCT CASE WHEN si.incident_type = 'bug' THEN si.incident_id END) as bugs,
    COUNT(DISTINCT CASE WHEN si.incident_type = 'performance' THEN si.incident_id END) as performance_issues,
    -- Resolution metrics
    AVG(CASE WHEN si.incident_status = 'resolved' THEN si.resolution_time_days END) as avg_resolution_time_days,
    AVG(si.user_satisfaction_score) as avg_satisfaction_score,
    -- Known issues
    STRING_AGG(DISTINCT CASE WHEN ki.known_issue = TRUE THEN si.description END, '; ') as active_known_issues
FROM silver.software_incidents si
JOIN silver.software_product sp ON si.software_product_id = sp.software_product_id
LEFT JOIN silver.known_issues ki ON si.error_code = ki.error_code
WHERE si.reported_date >= CURRENT_DATE - INTERVAL '30 days'
GROUP BY si.software_product_id, sp.software_name, sp.vendor_name;

Metrics Calculated:

Incident ticket ID and status
Expected resolution time (SLA)
Assigned support team
Known issues (proactive notification)
Self-service solutions available
Historical resolution times

Cerebro Enhancement

Memory: Track user's previous incidents and resolutions
Intelligence: Detect common issues and suggest KB articles before creating ticket
Intelligence: Auto-populate diagnostic information (device, OS, error logs)
Reasoning: Route to appropriate support team based on issue type
Reasoning: Suggest workarounds for known issues

UI Representation

Component: Copilot conversational incident reporting with smart diagnostics

Visualization:

┌─────────────────────────────────────────────────────────────┐
│ 💬 Copilot - Software Support                              │
├─────────────────────────────────────────────────────────────┤
│ You: Figma keeps crashing when I try to export             │
│                                                             │
│ 🤖 Copilot: I'm sorry you're experiencing issues with      │
│    Figma. Let me help troubleshoot.                         │
│                                                             │
│    🔍 Quick Check:                                          │
│    ✓ Your Figma license is active                          │
│    ✓ You're on the latest version (v116.2)                 │
│    ⚠️  Detected: 3 crash reports from your device          │
│                                                             │
│    💡 Known Issue: Figma export crashes on macOS 14.2 with │
│       files over 50MB. This is being fixed in next update. │
│                                                             │
│    🛠️ Try These Workarounds:                               │
│    1. Export in smaller sections                            │
│    2. Clear Figma cache (I can guide you)                   │
│    3. Use Figma web version temporarily                     │
│                                                             │
│    Still not working? I can create a support ticket for you.│
│                                                             │
│    📋 Ticket Details (pre-filled):                          │
│    • Issue: Figma export crashes                            │
│    • Software: Figma Professional                           │
│    • Device: MacBook Pro, macOS 14.2                        │
│    • Severity: Medium (work impacted but workaround exists) │
│    • Assigned to: Design Tools Support Team                 │
│    • Expected resolution: 1-2 business days                 │
│                                                             │
│ [Try Workarounds] [Create Support Ticket] [Call IT Hotline]│
└─────────────────────────────────────────────────────────────┘

Interactions:

Natural language problem description
Copilot performs diagnostics automatically
Suggests self-service solutions first
Checks for known issues
Pre-fills ticket with diagnostics
Routes to appropriate support team
Sets expectations (SLA, resolution time)
Follow up on ticket status

Copilot Query Example:

"I can't log into Microsoft Teams"

Answer: "Let me check your Teams access... I found the issue: Your Teams license expired yesterday due to a billing issue (IT is working on it). Expected resolution: today by 5 PM. Workaround: Use Teams web version (teams.microsoft.com) - your account still works there. I've notified IT that you're impacted. You'll receive an email when resolved. Need urgent help? Call IT hotline: x1234."

Q10: What are the alternatives if I can't get approved?

Why it matters: Users need productive paths forward when their first-choice software request is denied, ensuring they can still accomplish their work goals.

Telemetry Sources

Source	Data Retrieved	API Endpoint	Refresh Frequency
Service Catalog	Software catalog, alternatives, free tools	Service catalog API	Daily
Procurement	Existing licenses with available seats	Procurement system API	Hourly
Usage Analytics	Popular tools by department/role	Usage telemetry API	Daily
Service Desk	Rejection reasons, alternative recommendations	ServiceNow `/table/sc_request`	Real-time

L1 Analytics (Bronze→Silver)

-- Map alternatives based on use case and availability
CREATE TABLE silver.software_alternatives_catalog AS
SELECT
    sp.software_product_id as requested_software_id,
    sp.software_name as requested_software_name,
    sp.category,
    sp.use_case,
    -- Alternative options
    alt.software_product_id as alternative_software_id,
    alt.software_name as alternative_software_name,
    alt.vendor_name as alternative_vendor,
    alt_rel.relationship_type, -- 'free_alternative', 'cheaper_alternative', 'similar_features', 'partial_solution'
    alt_rel.feature_overlap_pct,
    alt_rel.capability_comparison,
    -- Availability
    CASE
        WHEN alt_lic.available_seats > 0 THEN 'seats_available'
        WHEN alt.cost = 0 THEN 'free_tool'
        WHEN alt.trial_available = TRUE THEN 'trial_available'
        ELSE 'request_required'
    END as availability_status,
    alt_lic.available_seats,
    alt.unit_cost as alternative_cost,
    sp.unit_cost as requested_cost,
    -- Usage context
    COUNT(DISTINCT dept_users.pii_id) as users_in_your_department,
    alt.approval_rate_pct,
    alt.avg_approval_time_days
FROM silver.software_product sp
JOIN silver.software_relationship alt_rel ON sp.software_product_id = alt_rel.software_product_id
JOIN silver.software_product alt ON alt_rel.related_software_product_id = alt.software_product_id
LEFT JOIN silver.software_license alt_lic ON alt.software_product_id = alt_lic.software_product_id
LEFT JOIN silver.license_assignment dept_users ON alt.software_product_id = dept_users.software_product_id
WHERE alt_rel.relationship_type IN ('free_alternative', 'cheaper_alternative', 'similar_features', 'partial_solution')
GROUP BY /* all columns */;

Transformations:

Identify free and cheaper alternatives
Map to existing tools with available seats
Highlight tools already used by peers
Include trial options

L2 Analytics (Silver→Gold)

-- Rank alternatives by feasibility and fit
CREATE TABLE gold.alternative_recommendations AS
SELECT
    sac.requested_software_id,
    sac.requested_software_name,
    sac.category,
    sac.alternative_software_id,
    sac.alternative_software_name,
    sac.availability_status,
    sac.feature_overlap_pct,
    sac.alternative_cost,
    sac.requested_cost,
    sac.users_in_your_department,
    -- Feasibility score
    CASE
        WHEN sac.availability_status = 'free_tool' THEN 100
        WHEN sac.availability_status = 'seats_available' THEN 90
        WHEN sac.availability_status = 'trial_available' THEN 70
        ELSE 50
    END as feasibility_score,
    -- Feature fit score
    sac.feature_overlap_pct as feature_fit_score,
    -- Department adoption score
    (sac.users_in_your_department::FLOAT / NULLIF(dept_size.total_users, 0) * 100) as dept_adoption_pct,
    -- Overall recommendation score
    (feasibility_score * 0.4 + feature_fit_score * 0.4 + dept_adoption_pct * 0.2) as recommendation_score,
    ROW_NUMBER() OVER (PARTITION BY sac.requested_software_id ORDER BY recommendation_score DESC) as recommendation_rank
FROM silver.software_alternatives_catalog sac
JOIN (SELECT department_name, COUNT(DISTINCT pii_id) as total_users FROM silver.user_directory GROUP BY department_name) dept_size
  ON dept_size.department_name = current_user_department
ORDER BY recommendation_score DESC;

Metrics Calculated:

Free alternatives (no cost, no approval needed)
Cheaper alternatives (lower cost)
Tools already licensed (available seats)
Trial options (try before requesting)
Feature overlap (how well it meets needs)
Peer adoption (who else uses it)

Cerebro Enhancement

Memory: Track user's work context and specific needs
Intelligence: Recommend best-fit alternatives based on use case
Intelligence: Predict approval likelihood for alternative requests
Reasoning: Suggest combination of free tools to match requested features
Reasoning: Explain trade-offs (what features you'll lose/gain)

UI Representation

Component: Copilot conversational alternative recommendation engine

Visualization:

┌─────────────────────────────────────────────────────────────┐
│ 💬 Copilot - Alternative Solutions                         │
├─────────────────────────────────────────────────────────────┤
│ You: My request for Adobe Premiere Pro was rejected        │
│                                                             │
│ 🤖 Copilot: I understand that's frustrating. Let me help   │
│    you find alternatives for video editing:                 │
│                                                             │
│    🎯 Best Alternatives:                                    │
│                                                             │
│    1. ✓ DaVinci Resolve (FREE) - Recommended               │
│       • Cost: $0 (company approved free tool)               │
│       • Features: 85% overlap with Premiere Pro             │
│       • Used by: 12 people in Marketing                     │
│       • Best for: Color grading, professional editing       │
│       • Limitation: Steeper learning curve                  │
│       [Download Now] [Watch Tutorial]                       │
│                                                             │
│    2. ✓ Camtasia (Seats Available)                         │
│       • Cost: $299/year (vs. $240/year for Premiere)       │
│       • Features: 60% overlap (simpler, faster)             │
│       • Available seats: 3 of 15 licenses open              │
│       • Used by: 15 people in Marketing (high approval rate)│
│       • Best for: Screencasts, training videos              │
│       [Request Access - Auto-approved]                      │
│                                                             │
│    3. 🔄 Microsoft Clipchamp (You Already Have It!)        │
│       • Cost: $0 (included with Microsoft 365)              │
│       • Features: 40% overlap (basic editing only)          │
│       • Best for: Quick edits, social media clips           │
│       • Limitation: Limited advanced features               │
│       [Open Clipchamp]                                      │
│                                                             │
│    💡 My Recommendation:                                    │
│    Start with DaVinci Resolve (free) for professional work,│
│    and use Clipchamp for quick edits. If you need more,    │
│    request Camtasia (high approval rate for Marketing).     │
│                                                             │
│ [Get DaVinci] [Request Camtasia] [Talk to Manager]         │
└─────────────────────────────────────────────────────────────┘

Interactions:

Natural language query: "My request was rejected, what can I do?"
Copilot identifies rejection reason and suggests alternatives
Ranks by feasibility (free → available seats → trial → new request)
Shows feature comparison and trade-offs
Highlights what colleagues use
Guides to immediate solutions (free tools, existing licenses)
Explains when to escalate vs. use alternatives

Copilot Query Example:

"I can't get Figma approved. What else can I use for wireframing?"

Answer: "Here are wireframing alternatives: 1) Miro (you already have it!) - great for low-fidelity wireframes and has a wireframing template library, 2) Penpot (free, open-source Figma alternative) - 70% feature overlap, 3) Adobe XD (available seats: 5) - similar to Figma for UI design. For your use case (Product Manager creating basic wireframes), I recommend starting with Miro since you already have access. 18 product managers in your team use it for wireframing."

Q11: My role changed - what software should I have now?

Why it matters: When users change roles, they need clarity on what software access should change, what they'll keep, and what new tools they should request.

Telemetry Sources

Source	Data Retrieved	API Endpoint	Refresh Frequency
HR System	Role changes, department transfers	HRIS API	Daily
IDP	Current entitlements, group memberships	SCIM `/Users`	Real-time
Service Catalog	Role-based software standards	Service catalog API	Daily
Usage Analytics	Software usage by role/department	Usage telemetry API	Daily

L1 Analytics (Bronze→Silver)

-- Detect role changes and software entitlement deltas
CREATE TABLE silver.role_change_software_impact AS
SELECT
    rc.pii_id,
    u.display_name,
    u.email,
    -- Role change details
    rc.effective_date,
    rc.previous_job_title,
    rc.new_job_title,
    rc.previous_department_name,
    rc.new_department_name,
    rc.change_type, -- 'promotion', 'transfer', 'lateral_move'
    -- Current entitlements
    la.software_product_id,
    sp.software_name,
    la.assignment_date,
    -- Software recommendations for new role
    rbp.recommended_for_role,
    rbp.required_for_role,
    rbp.optional_for_role,
    -- Peer comparison
    COUNT(DISTINCT peer_la.pii_id) as peers_in_new_role_with_this_software,
    COUNT(DISTINCT peer_u.pii_id) as total_peers_in_new_role,
    -- Action needed
    CASE
        WHEN rbp.required_for_role = TRUE AND la.license_assignment_id IS NULL THEN 'request_required'
        WHEN rbp.recommended_for_role = TRUE AND la.license_assignment_id IS NULL THEN 'request_recommended'
        WHEN rbp.required_for_role = FALSE AND rbp.recommended_for_role = FALSE AND la.license_assignment_id IS NOT NULL THEN 'consider_removal'
        ELSE 'no_change'
    END as action_needed
FROM bronze.role_change rc
JOIN silver.user_directory u ON rc.pii_id = u.pii_id
LEFT JOIN silver.license_assignment la ON rc.pii_id = la.pii_id
LEFT JOIN silver.software_product sp ON la.software_product_id = sp.software_product_id
LEFT JOIN silver.role_based_policy rbp ON rc.new_job_title = rbp.job_title AND sp.software_product_id = rbp.software_product_id
-- Compare to peers in new role
LEFT JOIN silver.user_directory peer_u ON rc.new_job_title = peer_u.job_title AND rc.new_department_name = peer_u.department_name
LEFT JOIN silver.license_assignment peer_la ON peer_u.pii_id = peer_la.pii_id AND sp.software_product_id = peer_la.software_product_id
WHERE rc.effective_date >= CURRENT_DATE - INTERVAL '90 days'
GROUP BY /* all columns */;

Transformations:

Detect recent role changes from HR system
Compare current entitlements to role-based policies
Identify software to add, keep, or remove
Benchmark against peers in new role

L2 Analytics (Silver→Gold)

-- Aggregate role transition software recommendations
CREATE TABLE gold.role_transition_recommendations AS
SELECT
    rcsi.pii_id,
    rcsi.display_name,
    rcsi.previous_job_title,
    rcsi.new_job_title,
    rcsi.effective_date,
    -- Software to add
    COUNT(DISTINCT CASE WHEN rcsi.action_needed = 'request_required' THEN rcsi.software_product_id END) as software_to_add_required,
    COUNT(DISTINCT CASE WHEN rcsi.action_needed = 'request_recommended' THEN rcsi.software_product_id END) as software_to_add_recommended,
    STRING_AGG(DISTINCT CASE WHEN rcsi.action_needed = 'request_required' THEN rcsi.software_name END, ', ') as required_software_list,
    STRING_AGG(DISTINCT CASE WHEN rcsi.action_needed = 'request_recommended' THEN rcsi.software_name END, ', ') as recommended_software_list,
    -- Software to potentially remove
    COUNT(DISTINCT CASE WHEN rcsi.action_needed = 'consider_removal' THEN rcsi.software_product_id END) as software_to_review,
    STRING_AGG(DISTINCT CASE WHEN rcsi.action_needed = 'consider_removal' THEN rcsi.software_name END, ', ') as review_software_list,
    -- Software to keep
    COUNT(DISTINCT CASE WHEN rcsi.action_needed = 'no_change' THEN rcsi.software_product_id END) as software_to_keep,
    -- Peer context
    AVG(rcsi.peers_in_new_role_with_this_software::FLOAT / NULLIF(rcsi.total_peers_in_new_role, 0) * 100) as avg_peer_adoption_pct
FROM silver.role_change_software_impact rcsi
GROUP BY rcsi.pii_id, rcsi.display_name, rcsi.previous_job_title, rcsi.new_job_title, rcsi.effective_date;

Metrics Calculated:

Software required for new role (must request)
Software recommended for new role (peers use it)
Software to retain from old role
Software to remove/reclaim (no longer needed)
Peer adoption rates in new role
Automated provisioning status

Cerebro Enhancement

Memory: Track user's role history and software transitions
Intelligence: Predict software needs based on new role and department
Intelligence: Identify which current software to keep vs. remove
Reasoning: Generate prioritized onboarding software checklist
Reasoning: Suggest proactive requests before role change effective date

UI Representation

Component: Copilot conversational role transition assistant

Visualization:

┌─────────────────────────────────────────────────────────────┐
│ 💬 Copilot - Role Transition Assistant                     │
├─────────────────────────────────────────────────────────────┤
│ You: I just moved from Product Manager to Senior PM        │
│                                                             │
│ 🤖 Copilot: Congratulations on your promotion! Let me help │
│    you get the right software for your new role.            │
│                                                             │
│    📋 Your Software Transition Plan:                        │
│                                                             │
│    ✅ Keep (You're All Set)                                 │
│    • Figma (used by 95% of Senior PMs)                      │
│    • Jira (used by 100% of Senior PMs)                      │
│    • Microsoft 365                                          │
│    • Slack                                                  │
│    • Zoom                                                   │
│                                                             │
│    ➕ Add (Request These)                                   │
│    • Productboard - REQUIRED for Senior PMs                 │
│      └─ Used by: 18 of 20 Senior PMs                        │
│      └─ Purpose: Product roadmap planning                   │
│      └─ Cost: $249/month (auto-approved for Senior PMs)     │
│      └─ [Request Now]                                       │
│                                                             │
│    • Amplitude Analytics - Recommended                      │
│      └─ Used by: 14 of 20 Senior PMs                        │
│      └─ Purpose: Product analytics and insights             │
│      └─ [Request Now]                                       │
│                                                             │
│    ❓ Review (Optional - Rarely Used in New Role)           │
│    • Miro - Keep only if you run workshops                  │
│      └─ Used by: 3 of 20 Senior PMs                         │
│      └─ Unused for 60 days - consider removing to save      │
│          company $48/year                                    │
│                                                             │
│    💡 I've created a draft request for Productboard since   │
│       it's required for your new role. Want me to submit?   │
│                                                             │
│ [Request Required Software] [View Peer Software] [Customize]│
└─────────────────────────────────────────────────────────────┘

Interactions:

Natural language query: "My role changed to X"
Copilot detects role change from HR system
Shows software to keep, add, and review
Highlights required vs. recommended
Shows peer adoption rates
Pre-fills requests for required software
Offers to submit requests automatically
Explains why certain software is recommended

Copilot Query Example:

"I'm transitioning from Marketing Coordinator to Marketing Manager"

Answer: "Congratulations! Here's your software transition plan: KEEP: Adobe Creative Cloud, Salesforce, Microsoft 365. ADD: Asana (required for Marketing Managers - 100% have it), Google Analytics (recommended - 85% have it), Hootsuite (recommended - 70% have it). REVIEW: Canva (only 20% of managers use it, consider Adobe CC instead). I can submit requests for Asana and Google Analytics now - both are typically auto-approved for Marketing Managers. Ready?"

Overview​

Table of Contents​

Q1: What software do I have access to?​

Telemetry Sources​

L1 Analytics (Bronze→Silver)​

L2 Analytics (Silver→Gold)​

Cerebro Enhancement​

UI Representation​

Q2: How do I request new software I need for my job?​

Telemetry Sources​

L1 Analytics (Bronze→Silver)​

L2 Analytics (Silver→Gold)​

Cerebro Enhancement​

UI Representation​

Q3: How much does this software cost the company?​

Telemetry Sources​

L1 Analytics (Bronze→Silver)​

L2 Analytics (Silver→Gold)​

Cerebro Enhancement​

UI Representation​

Q4: When was my software licensed?​

Telemetry Sources​

L1 Analytics (Bronze→Silver)​

L2 Analytics (Silver→Gold)​

Cerebro Enhancement​

UI Representation​

Q5: Who approved my software access?​

Telemetry Sources​

L1 Analytics (Bronze→Silver)​

L2 Analytics (Silver→Gold)​

Cerebro Enhancement​

UI Representation​

Q6: Can I switch to a different software tool?​

Telemetry Sources​

L1 Analytics (Bronze→Silver)​

L2 Analytics (Silver→Gold)​

Cerebro Enhancement​

UI Representation​

Q7: Who can I ask about software capabilities?​

Telemetry Sources​

L1 Analytics (Bronze→Silver)​

L2 Analytics (Silver→Gold)​

Cerebro Enhancement​

UI Representation​

Q8: Why don't I have access to specific software?​

Telemetry Sources​

L1 Analytics (Bronze→Silver)​

L2 Analytics (Silver→Gold)​

Cerebro Enhancement​

UI Representation​

Q9: How do I report a software issue?​

Telemetry Sources​

L1 Analytics (Bronze→Silver)​

L2 Analytics (Silver→Gold)​

Cerebro Enhancement​

UI Representation​

Q10: What are the alternatives if I can't get approved?​

Telemetry Sources​

L1 Analytics (Bronze→Silver)​

L2 Analytics (Silver→Gold)​

Cerebro Enhancement​

UI Representation​

Q11: My role changed - what software should I have now?​

Telemetry Sources​

L1 Analytics (Bronze→Silver)​

L2 Analytics (Silver→Gold)​

Cerebro Enhancement​

UI Representation​

Navigation​

Overview

Table of Contents

Q1: What software do I have access to?

Telemetry Sources

L1 Analytics (Bronze→Silver)

L2 Analytics (Silver→Gold)

Cerebro Enhancement

UI Representation

Q2: How do I request new software I need for my job?

Telemetry Sources

L1 Analytics (Bronze→Silver)

L2 Analytics (Silver→Gold)

Cerebro Enhancement

UI Representation

Q3: How much does this software cost the company?

Telemetry Sources

L1 Analytics (Bronze→Silver)

L2 Analytics (Silver→Gold)

Cerebro Enhancement

UI Representation

Q4: When was my software licensed?

Telemetry Sources

L1 Analytics (Bronze→Silver)

L2 Analytics (Silver→Gold)

Cerebro Enhancement

UI Representation

Q5: Who approved my software access?

Telemetry Sources

L1 Analytics (Bronze→Silver)

L2 Analytics (Silver→Gold)

Cerebro Enhancement

UI Representation

Q6: Can I switch to a different software tool?

Telemetry Sources

L1 Analytics (Bronze→Silver)

L2 Analytics (Silver→Gold)

Cerebro Enhancement

UI Representation

Q7: Who can I ask about software capabilities?

Telemetry Sources

L1 Analytics (Bronze→Silver)

L2 Analytics (Silver→Gold)

Cerebro Enhancement

UI Representation

Q8: Why don't I have access to specific software?

Telemetry Sources

L1 Analytics (Bronze→Silver)

L2 Analytics (Silver→Gold)

Cerebro Enhancement

UI Representation

Q9: How do I report a software issue?

Telemetry Sources

L1 Analytics (Bronze→Silver)

L2 Analytics (Silver→Gold)

Cerebro Enhancement

UI Representation

Q10: What are the alternatives if I can't get approved?

Telemetry Sources

L1 Analytics (Bronze→Silver)

L2 Analytics (Silver→Gold)

Cerebro Enhancement

UI Representation

Q11: My role changed - what software should I have now?

Telemetry Sources

L1 Analytics (Bronze→Silver)

L2 Analytics (Silver→Gold)

Cerebro Enhancement

UI Representation

Navigation