Your Dashboard Doesn't Explain Itself

Your dashboard doesn't explain itself. The analyst who built it already knows why "Q2 Margin Review" has twelve charts and what the filters mean. Everyone else opens the same board and stalls.

A director pulls it up with ninety seconds before their next meeting. Filters are set to something specific. The numbers moved. One question sits in front of them: what story is this telling right now, and do I need to act?

Usually they export a screenshot into ChatGPT, ask the analyst, or guess. The analyst re-explains the same filters from last week. Two days later the same director opens the same URL with a different date range, and yesterday's mental model is already wrong.

You open a dashboard someone else built. 12 charts. Filters you didn't choose. Metrics whose definitions live in one analyst's head. Your first question isn't "what's the number?" It's "what am I even looking at here?" Ad-hoc ChatGPT or a separate AI tool forces you to describe the filters and the board all over again. Or you just ping the author.

— Rt Kazakov (@RtKazakov) View on X

Preset's chatbot, Tableau Pulse, and Power BI Copilot chip away at pieces of this. Useful over nothing. They still leave the expensive moment untouched: the user is already inside a live view, filters applied, and needs grounded text without leaving the product or restating context they shouldn't have to restate.

A panel that reads the screen you're looking at

We built a side panel that lives on the dashboard itself, in our fork.

Trigger it from the board. It assembles context from exactly what's rendered right now:

• The active filter values and time window
• The charts currently visible and the datasets behind them
• Any artifact descriptions already generated for those objects

That grounded payload goes to the model. The response comes back as four fixed blocks a non-author can use:

• Summary — headline movement in plain language: week-over-week shifts, dominant drivers, share-of-mix changes
• What is happening — behavior across the current window, without forcing chart-by-chart decoding
• What looks unusual — anomalies relative to what you'd expect
• What to check next — a short numbered list of follow-up cuts

Change a filter and re-run. The briefing updates for the new slice. No paraphrase. No "I think they meant the global numbers this time."

History stays attached to that user and that dashboard. Come back tomorrow and pick up where you left off. Related boards surface as chips from the same semantic layer, so when this view isn't enough, the reader moves by meaning instead of guessing a title.

Same panel on the product page — comparison table, scope, and how it lands for management readers:

AI in SupersetAI dashboard analysis for Apache SupersetSide panel for people who open a board they didn't build — a structured read of what's on screen: summary, what's happening, what looks unusual, and what to check next.Open AI dashboard analysis

AI Analysis

• 01

  Summary

• 02

  What is happening

• 03

  Unusual signals

• 04

  Next checks

Why this exists: the author already gets it

The person who built the dashboard never asks "what am I looking at." Friction shows up the moment someone else opens their board: unfamiliar metrics, filters with no context, a dozen charts and no narrative tying them together.

"What's going on here?" goes back to the author. Every time. That's an org-chart problem wearing a data costume.

We put an AI panel on the dashboard: external LLM, prompts and context pulled from active filters and visible charts, running in your fork. The reader gets a briefing in the product. Four blocks. Skim in a minute instead of decoding chart by chart, or pinging the analyst for a walkthrough, or pasting a screenshot into ChatGPT.

In the product vs ad hoc: what actually changes

The model can be identical either way. The difference is whether the person looking at the board gets a ready briefing for what's on screen, or has to ask someone to translate it every time.

We've shipped versions of this for teams where the "ask the analyst" tax became the bottleneck once the catalog grew past a few dozen boards.

Structured output: why the four blocks stay fixed

The panel is for people opening a board without the author's insider knowledge. Each block answers something they'd otherwise have to ask.

Summary. Headline movement — week-over-week shifts, dominant categories, share-of-mix changes — the paragraph a director reads first without knowing the board's history.

What is happening. Behavior across the visible window in plain language: which segment drives volume, where metrics hold steady, where they drift.

What looks unusual. The anomaly layer: conversion dropping despite rising leads, a metric outside its normal band, whatever a non-analyst would miss.

What to check next. A numbered checklist so the reader (or the analyst, later) knows where to dig.

We kept these blocks stable on purpose. A repeatable shape is what lets a director trust the thing after the third use instead of re-learning the UI every time.

Scope of work: what we actually implement

The build is scoped and phased:

• Analysis trigger on the board, available to everyone with access — not a hidden command for power users only
• Per-user, per-dashboard conversation history, so someone can return to a prior briefing without a walkthrough from scratch
• Related dashboards via AI search: one-click chips to neighboring boards by meaning, composing with search when both are in scope
• External LLM, wired in. We connect the model API you already use. Context assembly and prompt templates live in the fork; the reader clicks a button

It pairs with the artifact generation work (the descriptions that make search reliable) and with MCP agents — different job, same semantic foundation underneath.

What we've actually seen change

What moves the needle is the drop in context-switching and the tribal-knowledge tax that used to sit on one or two analysts.

We've watched the same pattern repeat: stakeholders who used to interrupt an analyst two or three times a week for a translation start resolving most of it themselves in the product. The analyst still gets pinged, but the questions get sharper, because the easy ones already got answered by the panel.

Because the briefing is grounded in the exact charts on screen, the answers stay relevant as the view changes. External tools miss that part consistently — they answer for a snapshot, not the live state.

It also surfaces when the board itself needs work. A vague briefing, or one pointing at missing context, often means the dashboard or semantic layer needs attention before the AI can help. See our Superset AI capabilities.

How it composes with the rest of the AI layer

Once you also have AI-generated artifacts and semantic search in place:

• Artifacts supply the "why this board exists" context the briefing can reference
• Search surfaces related boards directly from the briefing
• The same grounding (live filters plus metadata) makes all three more reliable

We scope and wire this in phases, so you can start with analysis and add the foundation underneath it later.

Honest limitations

The briefing is only as good as the visible charts and the semantic layer's definitions. Bad metric names and messy filters show up in the text.

We mitigate that by feeding the panel strong artifact descriptions, using prompt templates that force citations to things visible in the current view, and letting users flag bad answers inside the panel so we can fix the prompts over time. Scoped fork work: you choose the model, you control the prompts, you decide the rollout.