AI Dashboard Examples

A BI dashboard where users type questions in plain English ('What were our top 5 products by revenue last quarter?') and the system generates SQL, runs the query, and presents results as charts or tables.

// Natural language to SQL dashboard
async function nlQueryDashboard(question, schema) {
  const sql = await llm.chat({
    messages: [{
      role: "system",
      content: `Generate SQL for this question. Schema: ${JSON.stringify(schema)}. Return only valid SQL.`
    }, { role: "user", content: question }]
  });

  // Validate and execute
  const validated = await validateSQL(sql); // Check for injection, limits
  const results = await db.query(validated);

  // Choose visualisation
  const chartType = await llm.chat({
    messages: [{ role: "user", content: `Best chart type for this data? Options: bar, line, pie, table. Data: ${JSON.stringify(results.columns)}` }]
  });

  return { data: results, chartType, query: validated };
}

A monitoring dashboard that uses AI to detect anomalies in business metrics — sudden drops in conversion rates, unusual traffic patterns, or inventory discrepancies — and surfaces them proactively with explanations.

// Anomaly detection for dashboards
async function detectAnomalies(metricData, historicalBaseline) {
  const anomalies = [];

  for (const metric of metricData) {
    const expected = historicalBaseline.predict(metric.name, metric.period);
    const deviation = Math.abs(metric.value - expected) / expected;

    if (deviation > 0.2) { // 20% deviation threshold
      const explanation = await llm.chat({
        messages: [{
          role: "system",
          content: "Explain this metric anomaly in business terms and suggest possible causes."
        }, { role: "user", content: JSON.stringify({ metric: metric.name, expected, actual: metric.value, deviation }) }]
      });
      anomalies.push({ ...metric, deviation, explanation, severity: deviation > 0.5 ? "critical" : "warning" });
    }
  }

  return anomalies;
}

A dashboard that generates daily executive summaries by analysing KPIs, comparing against targets, identifying trends, and highlighting items requiring attention. Delivered as a natural language briefing with supporting charts.

// Executive summary generation
async function generateExecutiveSummary(kpis, targets, period) {
  const performance = kpis.map(kpi => ({
    name: kpi.name,
    actual: kpi.value,
    target: targets[kpi.name],
    variance: ((kpi.value - targets[kpi.name]) / targets[kpi.name] * 100).toFixed(1),
    trend: kpi.trend,
  }));

  return await llm.chat({
    messages: [{
      role: "system",
      content: "Generate a concise executive summary. Lead with the most important items. Flag anything requiring action. Use business language, not technical jargon."
    }, { role: "user", content: JSON.stringify({ period, performance }) }]
  });
}

A sales dashboard that uses AI to forecast pipeline outcomes, predict deal close probabilities, identify at-risk deals, and recommend next-best-actions for sales reps. Integrates with CRM data and email activity.

// Predictive sales dashboard
async function predictDealOutcomes(deals) {
  return deals.map(deal => {
    const features = extractDealFeatures(deal); // stage, age, activity, engagement
    const probability = model.predict(features);
    const risks = identifyRisks(deal, features);

    const recommendation = llm.chat({
      messages: [{
        role: "system",
        content: "Suggest the single most impactful next action for this deal."
      }, { role: "user", content: JSON.stringify({ deal: deal.summary, probability, risks }) }]
    });

    return { dealId: deal.id, probability, risks, recommendation };
  });
}

A customer success dashboard that aggregates product usage, support tickets, NPS scores, and engagement data to calculate AI-driven health scores. Flags at-risk accounts and generates personalised retention recommendations.

// Customer health scoring
function calculateHealthScore(customer) {
  const signals = {
    usageFrequency: normalise(customer.loginDays / 30),
    featureAdoption: normalise(customer.featuresUsed / totalFeatures),
    supportSentiment: normalise(customer.avgTicketSentiment),
    npsScore: normalise(customer.latestNPS / 10),
    engagementTrend: customer.usageTrend, // -1 to 1
  };

  const weights = { usageFrequency: 0.25, featureAdoption: 0.2, supportSentiment: 0.2, npsScore: 0.15, engagementTrend: 0.2 };

  const score = Object.entries(signals).reduce(
    (sum, [key, val]) => sum + val * weights[key], 0
  );

  return { score, signals, risk: score < 0.4 ? "high" : score < 0.7 ? "medium" : "low" };
}