M365 LicenseDashboard

01PS> Get-Content .\docs\problem.md

Il problema

The problem

In un tenant Microsoft 365 enterprise le licenze sono una delle voci di costo più rilevanti, e anche una delle più difficili da tenere sotto controllo. Il portale di amministrazione mostra i dati, ma non aggregato, non in tempo reale e non con la profondità necessaria per prendere decisioni rapide.

In an enterprise Microsoft 365 tenant, licenses are one of the most significant cost items, and one of the hardest to keep under control. The admin portal shows the data, but not aggregated, not in real time and not with the depth needed to make quick decisions.

Domande come "Quante licenze M365 sono assegnate direttamente invece che tramite gruppo?", "Ci sono utenti inattivi da mesi che consumano ancora licenze?" o "Tra quanto saturiamo il piano corrente?" richiedono normalmente query manuali su Graph API o script PowerShell eseguiti all'occorrenza.

Questions like "How many M365 licenses are assigned directly instead of through a group?", "Are there users who have been inactive for months and still consume licenses?" or "How long until we saturate the current plan?" usually require manual Graph API queries or PowerShell scripts run on demand.

02PS> Get-Content .\docs\solution.md

La soluzione

The solution

Ho costruito una dashboard web a singolo file HTML che si connette a Microsoft Graph API tramite un backend serverless su Azure Functions e mostra in tempo reale lo stato completo delle licenze del tenant: utilizzo, assegnazioni, utenti inattivi, trend storico e alert consolidati.

I built a single-file HTML web dashboard that connects to Microsoft Graph API through a serverless backend on Azure Functions and shows the full license status of the tenant in real time: usage, assignments, inactive users, historical trend and consolidated alerts.

L'obiettivo era avere uno strumento sempre disponibile (accessibile da browser senza installare nulla, senza eseguire script manuali) che fornisse una vista centralizzata e azionabile sulle licenze M365.

The goal was an always-available tool (accessible from the browser without installing anything or running manual scripts) providing a centralized, actionable view of M365 licenses.

Come funziona

How it works

Browser (dashboard HTML)
  │  [non autenticato] → redirect /.auth/login/aad
  │  [autenticato]     → accesso alla dashboard
  ▼
Azure Static Web Apps (Easy Auth · Entra ID)
  │  fetch → /api/GetM365Data
  ▼
Azure Function (PowerShell HTTP trigger)
  │  OAuth2 client credentials → access token
  ▼
Microsoft Graph API
  │  GET /organization · /subscribedSkus · /users
  ▼
Azure Function elabora i dati
  │  upsert snapshot mese corrente ──► Azure Table Storage
  │  GET ultimi 12 mesi di storico ◄──────────────────────
  ▼
Browser renderizza la dashboard

Browser (HTML dashboard)
  │  [not signed in] → redirect /.auth/login/aad
  │  [signed in]     → access to the dashboard
  ▼
Azure Static Web Apps (Easy Auth · Entra ID)
  │  fetch → /api/GetM365Data
  ▼
Azure Function (PowerShell HTTP trigger)
  │  OAuth2 client credentials → access token
  ▼
Microsoft Graph API
  │  GET /organization · /subscribedSkus · /users
  ▼
Azure Function processes the data
  │  upsert current month snapshot ──► Azure Table Storage
  │  GET last 12 months of history ◄───────────────────────
  ▼
Browser renders the dashboard

Il frontend è un file HTML vanilla con Chart.js per i grafici: nessun framework, nessun build step. Il backend è una Azure Function in PowerShell che autentica l'app tramite OAuth 2.0 con credenziali client (app-only, senza utente interattivo) e interroga Graph API recuperando dati su licenze e utenti. I nomi leggibili delle licenze (es. "Microsoft 365 E3" invece di "ENTERPRISEPACK") vengono mappati in tempo reale scaricando il CSV ufficiale Microsoft. Ad ogni chiamata, la Function salva uno snapshot mensile su Azure Table Storage per alimentare il grafico del trend storico.

The frontend is a vanilla HTML file with Chart.js for the charts: no framework, no build step. The backend is a PowerShell Azure Function that authenticates the app via OAuth 2.0 client credentials (app-only, no interactive user) and queries Graph API for license and user data. Friendly license names (e.g. "Microsoft 365 E3" instead of "ENTERPRISEPACK") are mapped in real time by downloading Microsoft's official CSV. On every call, the Function saves a monthly snapshot to Azure Table Storage to feed the historical trend chart.

03PS> Get-ChildItem .\features

Cosa mostra la dashboard

What the dashboard shows

La dashboard è organizzata in sezioni distinte, ognuna pensata per rispondere a una domanda specifica.

The dashboard is organized into distinct sections, each designed to answer a specific question.

04PS> Get-Content .\stack.json | ConvertFrom-Json

Stack tecnico

Tech stack

Il progetto è volutamente minimalista lato dipendenze: tutto quello che serve è già nell'ecosistema Azure e Microsoft.

The project is deliberately minimal on dependencies: everything it needs is already in the Azure and Microsoft ecosystem.

# Recupero token OAuth2 con client credentials# Get an OAuth2 token with client credentials
$body = @{
    grant_type    = "client_credentials"
    client_id     = $env:CLIENT_ID
    client_secret = $env:CLIENT_SECRET
    scope         = "https://graph.microsoft.com/.default"
}
$token = (Invoke-RestMethod `
    "https://login.microsoftonline.com/$env:TENANT_ID/oauth2/v2.0/token" `
    -Method POST `
    -Body $body).access_token

# Lettura licenze del tenant# Read the tenant licenses
$skus = (Invoke-RestMethod `
    "https://graph.microsoft.com/v1.0/subscribedSkus" `
    -Headers @{ Authorization = "Bearer $token" }).value

05PS> Get-History

Cosa ho imparato

What I learned

Costruire questo progetto da zero mi ha fatto toccare con mano alcuni aspetti dell'ecosistema Microsoft cloud che normalmente si gestiscono solo tramite portale. In particolare:

Building this project from scratch gave me hands-on experience with aspects of the Microsoft cloud ecosystem that are normally handled only through the portal. In particular:

1. Il flusso OAuth 2.0 Client Credentials: capire come un'app si autentica senza utente interattivo, come funziona il token e come gestire i permessi Application vs Delegated su Graph API.The OAuth 2.0 Client Credentials flow: understanding how an app authenticates without an interactive user, how the token works and how to handle Application vs Delegated permissions on Graph API.
2. La struttura dei dati licenze in Graph: il campo licenseAssignmentStates per ogni utente e la distinzione tra assegnazione diretta e da gruppo non è immediata da leggere, richiede un po' di parsing.The structure of license data in Graph: each user's licenseAssignmentStates field and the distinction between direct and group-based assignment aren't immediately readable and need some parsing.
3. Azure Functions in PowerShell: come strutturare una function HTTP trigger, come passare variabili d'ambiente in modo sicuro e come gestire CORS per permettere le chiamate dal frontend.Azure Functions in PowerShell: how to structure an HTTP-trigger function, how to pass environment variables securely and how to handle CORS to allow calls from the frontend.
4. Sign-in activity: interattivo vs non-interattivo: Graph API espone due date di accesso distinte per ogni utente. Ho capito la differenza pratica: un token refresh automatico (SSO, servizio in background) aggiorna il dato non-interattivo ma non quello interattivo. Usare solo quest'ultimo per la soglia di inattività è la scelta corretta per identificare utenti che non aprono più le app Microsoft, pur mantenendo entrambi i valori visibili a schermo.Sign-in activity: interactive vs non-interactive: Graph API exposes two separate sign-in dates for each user. I learned the practical difference: an automatic token refresh (SSO, background service) updates the non-interactive date but not the interactive one. Using only the latter for the inactivity threshold is the right choice to identify users who no longer open Microsoft apps, while keeping both values visible on screen.
5. Governance degli account disabilitati: un account disabilitato in Entra ID non rilascia automaticamente le licenze assegnate direttamente. Rilevare e segnalare questi casi nella dashboard traduce un problema di governance spesso invisibile in un'azione concreta e misurabile.Governance of disabled accounts: an account disabled in Entra ID does not automatically release directly assigned licenses. Detecting and flagging these cases in the dashboard turns an often invisible governance problem into a concrete, measurable action.
6. Azure Table Storage via REST API diretta: per lo storico del trend ho implementato l'autenticazione SharedKeyLite con HMAC-SHA256 in puro PowerShell, senza dipendere da moduli esterni. Un esercizio utile per capire come funziona l'autenticazione a livello di protocollo nei servizi Azure Storage.Azure Table Storage via the REST API: for the trend history I implemented SharedKeyLite authentication with HMAC-SHA256 in pure PowerShell, without depending on external modules. A useful exercise to understand how authentication works at protocol level in Azure Storage services.
7. Il deploy automatico con Azure Static Web Apps: ogni push su GitHub aggiorna il sito in automatico tramite GitHub Actions, senza deploy manuale.Automatic deployment with Azure Static Web Apps: every push to GitHub updates the site automatically through GitHub Actions, with no manual deployment.
8. Migrazione a Azure DevOps: come spostare un progetto interamente nell'ecosistema Microsoft (Azure Repos + Azure Pipelines) per scenari enterprise dove i dati non devono uscire dall'infrastruttura del cliente.Migrating to Azure DevOps: how to move a project entirely into the Microsoft ecosystem (Azure Repos + Azure Pipelines) for enterprise scenarios where data must not leave the customer's infrastructure.
9. Proteggere una web app con Entra ID Easy Auth: come aggiungere autenticazione Microsoft a una Static Web App tramite staticwebapp.config.json, con la distinzione pratica tra il provider built-in (piano Free) e l'app registration custom (piano Standard).Protecting a web app with Entra ID Easy Auth: how to add Microsoft authentication to a Static Web App through staticwebapp.config.json, with the practical difference between the built-in provider (Free plan) and a custom app registration (Standard plan).
10. Import dati storici su Table Storage via REST: implementazione di un handler POST nella Function che riceve dati JSON e li persiste su Azure Table Storage con upsert (PUT), usando la stessa autenticazione SharedKeyLite già presente per la lettura, senza dipendenze aggiuntive.Importing historical data into Table Storage via REST: a POST handler in the Function that receives JSON data and persists it to Azure Table Storage with an upsert (PUT), using the same SharedKeyLite authentication already used for reading, with no additional dependencies.

06PS> Get-Content .\ROADMAP.md

Sviluppi futuri

What's next

Il progetto è funzionante e in continua evoluzione. I miglioramenti ancora in cantiere:

The project works and keeps evolving. Improvements still in the pipeline: