Test Reports That Leadership Actually Reads: A QA Dashboard Design Guide

Your CEO asks, "How's our quality?"

You email a 47-page PDF test report. Hundreds of test cases listed in a table. Pass/fail counts. Some cryptic technical jargon.

Two days later, the CEO emails back: "I don't understand this. Can you just tell me if we're ready to launch?"

Your comprehensive test report just became shelfware.

Test reporting isn't about generating data—it's about communicating quality to stakeholders who make decisions based on what you tell them.

This comprehensive guide teaches you how to create test reports and QA dashboards that people actually use, implement Allure Reports for rich test documentation, build custom dashboards with real-time data, and present test metrics that drive actionable decisions.

The Test Reporting Problem

Why Most Test Reports Fail

Common Problem	Why It Fails	Stakeholder Impact
Too Technical	Full of selectors, stack traces, technical jargon	Non-technical stakeholders can't understand
Too Detailed	Lists every single test case	Information overload, can't see patterns
Too Late	Generated after tests finish, emailed daily	Decisions delayed, feedback loop broken
No Context	Just numbers, no trends or comparisons	Can't tell if improving or degrading
No Action Items	Reports what happened, not what to do	Stakeholders don't know how to respond

What Stakeholders Really Want

graph TD
    A[Different Stakeholders] --> B[CEO/Leadership]
    A --> C[Product Managers]
    A --> D[Developers]
    A --> E[QA Team]

    B --> F["Is quality improving?<br/>Are we ready to ship?<br/>What's the risk?"]
    C --> G["Which features are stable?<br/>What's blocking release?<br/>User impact?"]
    D --> H["Which tests are failing?<br/>What broke?<br/>How do I reproduce?"]
    E --> I["Test coverage?<br/>Flaky tests?<br/>Execution trends?"]

    style B fill:#ffcccc
    style C fill:#ccffcc
    style D fill:#ccccff
    style E fill:#ffffcc

Principles of Effective Test Reporting

1. Know Your Audience

interface ReportAudience {
  role: 'executive' | 'product' | 'engineering' | 'qa';
  needsDetailLevel: 'summary' | 'detailed' | 'granular';
  primaryQuestions: string[];
  actionableMetrics: string[];
}

const executiveReport: ReportAudience = {
  role: 'executive',
  needsDetailLevel: 'summary',
  primaryQuestions: ['Are we ready to ship?', 'What are the major risks?', 'Is quality improving over time?'],
  actionableMetrics: ['Pass rate trend', 'Critical bugs count', 'Release confidence score'],
};

const engineeringReport: ReportAudience = {
  role: 'engineering',
  needsDetailLevel: 'granular',
  primaryQuestions: ['Which tests are failing?', 'What changed in this commit?', 'How do I reproduce the failure?'],
  actionableMetrics: ['Failing test names', 'Error messages', 'Stack traces', 'Screenshots/videos'],
};

2. Show Trends, Not Just Snapshots

// ❌ BAD - Single data point
const report = {
  date: '2024-01-15',
  totalTests: 847,
  passed: 823,
  failed: 24,
  passRate: 97.2,
};

// ✅ GOOD - Trend over time
const trendReport = {
  current: {
    date: '2024-01-15',
    totalTests: 847,
    passed: 823,
    failed: 24,
    passRate: 97.2,
  },
  previous: {
    date: '2024-01-14',
    totalTests: 845,
    passed: 810,
    failed: 35,
    passRate: 95.9,
  },
  trend: {
    passRateChange: +1.3, // Improving!
    newFailures: 2,
    fixedFailures: 13,
    status: 'improving',
  },
  weeklyAverage: {
    passRate: 96.5,
    avgDuration: '12m 34s',
  },
};

3. Prioritize Actionable Information

interface ActionableReport {
  summary: {
    overallStatus: 'pass' | 'fail' | 'unstable';
    confidence: 'high' | 'medium' | 'low';
    recommendation: string;
  };
  blockers: Array<{
    severity: 'critical' | 'high' | 'medium' | 'low';
    issue: string;
    impact: string;
    suggestedAction: string;
    assignee?: string;
  }>;
  improvements: Array<{
    metric: string;
    change: number;
    reason?: string;
  }>;
}

const actionableReport: ActionableReport = {
  summary: {
    overallStatus: 'unstable',
    confidence: 'medium',
    recommendation: 'Fix 3 critical failures before release',
  },
  blockers: [
    {
      severity: 'critical',
      issue: 'Payment flow failing in checkout',
      impact: 'Blocks all purchases - revenue impact',
      suggestedAction: 'Revert commit abc123 or hotfix payment gateway',
      assignee: 'john@example.com',
    },
    {
      severity: 'high',
      issue: 'Login failing for 15% of users',
      impact: 'Partial user lockout',
      suggestedAction: 'Investigate session handling changes',
      assignee: 'sarah@example.com',
    },
  ],
  improvements: [
    {
      metric: 'Pass rate',
      change: +2.3,
      reason: 'Fixed 12 flaky tests',
    },
  ],
};

Implementing Allure Reports

Setup and Configuration

npm install --save-dev allure-playwright allure-commandline

// playwright.config.ts
import { defineConfig } from '@playwright/test';

export default defineConfig({
  reporter: [
    ['list'], // Console output
    ['html'], // HTML report
    [
      'allure-playwright',
      {
        outputFolder: 'allure-results',
        detail: true,
        suiteTitle: true,
      },
    ],
  ],
  use: {
    trace: 'retain-on-failure',
    screenshot: 'only-on-failure',
    video: 'retain-on-failure',
  },
});

Enriching Tests with Allure Metadata

import { test, expect } from '@playwright/test';
import { allure } from 'allure-playwright';

test('User can complete checkout', async ({ page }) => {
  // Add metadata
  await allure.epic('E-Commerce');
  await allure.feature('Checkout');
  await allure.story('Guest Checkout');
  await allure.owner('john@example.com');
  await allure.severity('critical');
  await allure.tag('smoke');
  await allure.tag('regression');

  // Add description with steps
  await allure.description('Verify guest users can complete purchase without account');

  // Step 1
  await allure.step('Navigate to product page', async () => {
    await page.goto('/products/laptop');
    await expect(page.locator('h1')).toContainText('Laptop');
  });

  // Step 2
  await allure.step('Add product to cart', async () => {
    await page.click('[data-testid="add-to-cart"]');
    await expect(page.locator('.cart-count')).toHaveText('1');
  });

  // Step 3
  await allure.step('Proceed to checkout', async () => {
    await page.click('[data-testid="checkout"]');
    await expect(page).toHaveURL(/.*\/checkout/);
  });

  // Step 4
  await allure.step('Fill shipping information', async () => {
    await page.fill('[name="email"]', 'guest@example.com');
    await page.fill('[name="address"]', '123 Main St');
    await page.fill('[name="city"]', 'San Francisco');

    // Attach data for debugging
    await allure.attachment(
      'Shipping Data',
      JSON.stringify({
        email: 'guest@example.com',
        address: '123 Main St',
        city: 'San Francisco',
      }),
      'application/json',
    );
  });

  // Step 5
  await allure.step('Complete payment', async () => {
    await page.fill('[name="cardNumber"]', '4242424242424242');
    await page.fill('[name="expiryDate"]', '12/25');
    await page.fill('[name="cvv"]', '123');
    await page.click('[data-testid="submit-payment"]');

    // Add link to related documentation
    await allure.link('Payment Docs', 'https://docs.example.com/payments');
  });

  // Step 6
  await allure.step('Verify order confirmation', async () => {
    await expect(page.locator('.order-success')).toBeVisible();
    const orderNumber = await page.locator('.order-number').textContent();

    await allure.parameter('Order Number', orderNumber);
  });
});

Custom Allure Fixture

// fixtures/allure-fixture.ts
import { test as base } from '@playwright/test';
import { allure } from 'allure-playwright';

export const test = base.extend({
  allureReporting: async ({}, use, testInfo) => {
    // Automatically add test metadata
    await allure.owner(testInfo.project.name);

    // Add CI/CD context
    if (process.env.CI) {
      await allure.parameter('CI Build', process.env.GITHUB_RUN_ID);
      await allure.parameter('Branch', process.env.GITHUB_REF_NAME);
      await allure.parameter('Commit', process.env.GITHUB_SHA?.substring(0, 7));
    }

    // Add environment info
    await allure.parameter('Test Environment', process.env.TEST_ENV || 'local');

    await use();

    // Add final status
    if (testInfo.status === 'failed') {
      await allure.severity('blocker');
    }
  },
});

Generating and Viewing Allure Reports

# Generate report from results
allure generate allure-results --clean -o allure-report

# Serve report locally
allure serve allure-results

# Or open static report
allure open allure-report

// package.json scripts
{
  "scripts": {
    "test": "playwright test",
    "test:report": "playwright test && allure generate allure-results --clean",
    "report:open": "allure open allure-report",
    "report:serve": "allure serve allure-results"
  }
}

Building Custom Test Dashboards

Real-Time Dashboard Architecture

// dashboard-server.ts
import express from 'express';
import { WebSocketServer } from 'ws';
import { TestResultsCollector } from './collectors';

const app = express();
const wss = new WebSocketServer({ port: 8080 });

// WebSocket connection for real-time updates
wss.on('connection', (ws) => {
  console.log('Dashboard client connected');

  // Send current state
  ws.send(JSON.stringify({
    type: 'initial',
    data: TestResultsCollector.getCurrent State(),
  }));

  // Subscribe to test updates
  TestResultsCollector.on('testComplete', (result) => {
    ws.send(JSON.stringify({
      type: 'testUpdate',
      data: result,
    }));
  });
});

// REST API for historical data
app.get('/api/test-runs', async (req, res) => {
  const { startDate, endDate, branch } = req.query;

  const runs = await TestResultsCollector.query({
    startDate: new Date(startDate as string),
    endDate: new Date(endDate as string),
    branch: branch as string,
  });

  res.json(runs);
});

app.get('/api/test-trends', async (req, res) => {
  const trends = await TestResultsCollector.calculateTrends({
    period: req.query.period as string,
    groupBy: req.query.groupBy as string,
  });

  res.json(trends);
});

app.listen(3000);

Dashboard Data Model

// models/dashboard-data.ts
export interface DashboardData {
  summary: TestSummary;
  recentRuns: TestRun[];
  trends: TrendData;
  flakyTests: FlakyTest[];
  slowTests: SlowTest[];
  failureAnalysis: FailurePattern[];
}

export interface TestSummary {
  currentRun: {
    id: string;
    startTime: Date;
    duration?: number;
    status: 'running' | 'completed' | 'failed';
    progress: {
      total: number;
      completed: number;
      passed: number;
      failed: number;
      skipped: number;
    };
  };
  lastRun: {
    passRate: number;
    duration: number;
    timestamp: Date;
  };
  comparison: {
    passRateDelta: number;
    durationDelta: number;
    newFailures: number;
    fixedFailures: number;
  };
}

export interface TrendData {
  daily: Array<{
    date: string;
    passRate: number;
    totalTests: number;
    duration: number;
  }>;
  weekly: Array<{
    week: string;
    avgPassRate: number;
    totalRuns: number;
  }>;
  monthlyComparison: {
    current: MonthStats;
    previous: MonthStats;
    improvement: number;
  };
}

export interface FlakyTest {
  testName: string;
  file: string;
  flakinessScore: number; // 0-100
  recentResults: Array<'pass' | 'fail'>;
  lastFailed: Date;
  failureRate: number;
}

export interface SlowTest {
  testName: string;
  file: string;
  avgDuration: number;
  maxDuration: number;
  percentile95: number;
  trend: 'improving' | 'stable' | 'degrading';
}

export interface FailurePattern {
  pattern: string;
  frequency: number;
  affectedTests: string[];
  firstSeen: Date;
  lastSeen: Date;
  suggestedFix?: string;
}

React Dashboard Component

// Dashboard.tsx
import React, { useEffect, useState } from 'react';
import { Line, Bar, Doughnut } from 'react-chartjs-2';

export function TestDashboard() {
  const [data, setData] = useState<DashboardData | null>(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    // Connect to WebSocket for real-time updates
    const ws = new WebSocket('ws://localhost:8080');

    ws.onmessage = (event) => {
      const message = JSON.parse(event.data);

      if (message.type === 'initial') {
        setData(message.data);
        setLoading(false);
      } else if (message.type === 'testUpdate') {
        setData(prev => updateWithNewTest(prev, message.data));
      }
    };

    return () => ws.close();
  }, []);

  if (loading) return <LoadingSpinner />;

  return (
    <div className="dashboard">
      {/* Summary Cards */}
      <div className="summary-cards">
        <SummaryCard
          title="Pass Rate"
          value={`${data.summary.lastRun.passRate.toFixed(1)}%`}
          trend={data.summary.comparison.passRateDelta}
          status={getStatusColor(data.summary.lastRun.passRate)}
        />
        <SummaryCard
          title="Total Tests"
          value={data.summary.currentRun.progress.total}
          subtitle={`${data.summary.currentRun.progress.completed} completed`}
        />
        <SummaryCard
          title="Duration"
          value={formatDuration(data.summary.lastRun.duration)}
          trend={data.summary.comparison.durationDelta}
          trendInverted // Lower is better
        />
        <SummaryCard
          title="Failures"
          value={data.summary.currentRun.progress.failed}
          trend={data.summary.comparison.newFailures}
          status={data.summary.currentRun.progress.failed === 0 ? 'success' : 'error'}
        />
      </div>

      {/* Charts */}
      <div className="charts">
        <div className="chart-container">
          <h2>Pass Rate Trend (30 Days)</h2>
          <Line
            data={{
              labels: data.trends.daily.map(d => d.date),
              datasets: [{
                label: 'Pass Rate %',
                data: data.trends.daily.map(d => d.passRate),
                borderColor: 'rgb(75, 192, 192)',
                tension: 0.1,
              }],
            }}
            options={{
              scales: {
                y: {
                  beginAtZero: false,
                  min: 90,
                  max: 100,
                },
              },
            }}
          />
        </div>

        <div className="chart-container">
          <h2>Test Distribution</h2>
          <Doughnut
            data={{
              labels: ['Passed', 'Failed', 'Skipped'],
              datasets: [{
                data: [
                  data.summary.currentRun.progress.passed,
                  data.summary.currentRun.progress.failed,
                  data.summary.currentRun.progress.skipped,
                ],
                backgroundColor: [
                  'rgb(75, 192, 192)',
                  'rgb(255, 99, 132)',
                  'rgb(255, 205, 86)',
                ],
              }],
            }}
          />
        </div>
      </div>

      {/* Tables */}
      <div className="tables">
        <div className="table-container">
          <h2>Flaky Tests ({data.flakyTests.length})</h2>
          <table>
            <thead>
              <tr>
                <th>Test Name</th>
                <th>Flakiness Score</th>
                <th>Failure Rate</th>
                <th>Last Failed</th>
              </tr>
            </thead>
            <tbody>
              {data.flakyTests.map(test => (
                <tr key={test.testName}>
                  <td>{test.testName}</td>
                  <td>
                    <ProgressBar value={test.flakinessScore} max={100} />
                  </td>
                  <td>{(test.failureRate * 100).toFixed(1)}%</td>
                  <td>{formatRelativeTime(test.lastFailed)}</td>
                </tr>
              ))}
            </tbody>
          </table>
        </div>

        <div className="table-container">
          <h2>Slowest Tests ({data.slowTests.length})</h2>
          <table>
            <thead>
              <tr>
                <th>Test Name</th>
                <th>Avg Duration</th>
                <th>95th Percentile</th>
                <th>Trend</th>
              </tr>
            </thead>
            <tbody>
              {data.slowTests.map(test => (
                <tr key={test.testName}>
                  <td>{test.testName}</td>
                  <td>{formatDuration(test.avgDuration)}</td>
                  <td>{formatDuration(test.percentile95)}</td>
                  <td>
                    <TrendIndicator trend={test.trend} />
                  </td>
                </tr>
              ))}
            </tbody>
          </table>
        </div>
      </div>
    </div>
  );
}

Key Performance Indicators (KPIs) for QA

Essential QA Metrics

KPI	Formula	Target	What It Tells You
Pass Rate	(Passed / Total) × 100	> 95%	Overall test health
Defect Escape Rate	(Prod Bugs / Total Bugs) × 100	< 5%	QA effectiveness
Test Coverage	(Covered LOC / Total LOC) × 100	> 80%	Code coverage
Mean Time to Detect (MTTD)	Avg time from bug introduction to detection	< 1 day	Detection speed
Mean Time to Repair (MTTR)	Avg time from bug detection to fix	< 4 hours	Fix speed
Flaky Test Rate	(Flaky Tests / Total) × 100	< 2%	Test reliability
Test Execution Time	Total duration of test suite	Trend ↓	CI/CD efficiency

Calculating Advanced Metrics

// metrics calculator.ts
export class QAMetricsCalculator {
  calculateDefectEscapeRate(productionBugs: number, totalBugsFound: number): number {
    return (productionBugs / totalBugsFound) * 100;
  }

  calculateTestStability(testResults: TestResult[]): number {
    const groupedByTest = this.groupBy(testResults, 'testName');
    let flakyCount = 0;

    for (const [testName, results] of Object.entries(groupedByTest)) {
      const statuses = results.map((r) => r.status);
      const hasBothPassAndFail = statuses.includes('pass') && statuses.includes('fail');

      if (hasBothPassAndFail) {
        flakyCount++;
      }
    }

    return ((Object.keys(groupedByTest).length - flakyCount) / Object.keys(groupedByTest).length) * 100;
  }

  calculateTestEfficiency(
    testResults: TestResult[],
    bugsFound: number,
  ): {
    testsPerBug: number;
    hoursPerBug: number;
    efficiency: 'high' | 'medium' | 'low';
  } {
    const totalTests = testResults.length;
    const totalHours = testResults.reduce((sum, r) => sum + r.duration, 0) / 3600000;

    const testsPerBug = totalTests / bugsFound;
    const hoursPerBug = totalHours / bugsFound;

    // Efficiency scoring
    let efficiency: 'high' | 'medium' | 'low';
    if (testsPerBug < 50 && hoursPerBug < 2) {
      efficiency = 'high';
    } else if (testsPerBug < 100 && hoursPerBug < 4) {
      efficiency = 'medium';
    } else {
      efficiency = 'low';
    }

    return { testsPerBug, hoursPerBug, efficiency };
  }

  calculateTrendDirection(values: number[]): 'improving' | 'stable' | 'degrading' {
    if (values.length < 2) return 'stable';

    const recent = values.slice(-7); // Last 7 data points
    const trend = this.linearRegression(recent);

    if (trend.slope > 0.5) return 'improving';
    if (trend.slope < -0.5) return 'degrading';
    return 'stable';
  }

  private linearRegression(values: number[]): { slope: number; intercept: number } {
    const n = values.length;
    const sumX = values.reduce((sum, _, i) => sum + i, 0);
    const sumY = values.reduce((sum, val) => sum + val, 0);
    const sumXY = values.reduce((sum, val, i) => sum + i * val, 0);
    const sumX2 = values.reduce((sum, _, i) => sum + i * i, 0);

    const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
    const intercept = (sumY - slope * sumX) / n;

    return { slope, intercept };
  }
}

Report Distribution Strategies

1. Email Reports

// email-reporter.ts
import nodemailer from 'nodemailer';
import { generateExecutiveSummary, generateDetailedReport } from './report-generator';

export async function sendTestReport(results: TestResults, recipients: string[]) {
  const transporter = nodemailer.createTransporter({
    host: process.env.SMTP_HOST,
    port: 587,
    auth: {
      user: process.env.SMTP_USER,
      pass: process.env.SMTP_PASS,
    },
  });

  const executiveSummary = generateExecutiveSummary(results);
  const detailedReport = generateDetailedReport(results);

  const subject =
    results.status === 'pass'
      ? `✅ Test Suite Passed - ${results.passRate.toFixed(1)}%`
      : `❌ Test Suite Failed - ${results.failedTests.length} failures`;

  await transporter.sendMail({
    from: 'qa@example.com',
    to: recipients.join(', '),
    subject,
    html: `
      <h1>${subject}</h1>
      
      <h2>Summary</h2>
      ${executiveSummary.html}
      
      <h2>Trend</h2>
      <img src="cid:trend-chart" />
      
      <h2>Action Items</h2>
      <ul>
        ${results.actionItems.map((item) => `<li>${item}</li>`).join('\n')}
      </ul>
      
      <p><a href="${process.env.DASHBOARD_URL}/runs/${results.id}">View Full Report</a></p>
    `,
    attachments: [
      {
        filename: 'detailed-report.html',
        content: detailedReport.html,
      },
      {
        filename: 'trend-chart.png',
        content: generateTrendChart(results),
        cid: 'trend-chart',
      },
    ],
  });
}

2. Slack Integration

// slack-reporter.ts
import { WebClient } from '@slack/web-api';

export class SlackReporter {
  private client: WebClient;

  constructor(token: string) {
    this.client = new WebClient(token);
  }

  async postTestResults(channel: string, results: TestResults) {
    const status = results.status === 'pass' ? ':white_check_mark:' : ':x:';
    const color = results.status === 'pass' ? '#36a64f' : '#ff0000';

    await this.client.chat.postMessage({
      channel,
      text: `Test Results: ${results.status}`,
      blocks: [
        {
          type: 'header',
          text: {
            type: 'plain_text',
            text: `${status} Test Run ${results.id}`,
          },
        },
        {
          type: 'section',
          fields: [
            {
              type: 'mrkdwn',
              text: `*Pass Rate:*\n${results.passRate.toFixed(1)}%`,
            },
            {
              type: 'mrkdwn',
              text: `*Duration:*\n${formatDuration(results.duration)}`,
            },
            {
              type: 'mrkdwn',
              text: `*Passed:*\n${results.passedTests.length}`,
            },
            {
              type: 'mrkdwn',
              text: `*Failed:*\n${results.failedTests.length}`,
            },
          ],
        },
        {
          type: 'section',
          text: {
            type: 'mrkdwn',
            text: `*Branch:* ${results.branch}\n*Commit:* \`${results.commit.slice(0, 7)}\``,
          },
        },
        {
          type: 'actions',
          elements: [
            {
              type: 'button',
              text: {
                type: 'plain_text',
                text: 'View Full Report',
              },
              url: `${process.env.DASHBOARD_URL}/runs/${results.id}`,
            },
            {
              type: 'button',
              text: {
                type: 'plain_text',
                text: 'View Allure Report',
              },
              url: `${process.env.ALLURE_URL}/runs/${results.id}`,
            },
          ],
        },
      ],
    });

    // Post failed tests in thread
    if (results.failedTests.length > 0) {
      const failureDetails = results.failedTests
        .slice(0, 10) // First 10
        .map((test) => `• *${test.name}*\n  ${test.error}`)
        .join('\n\n');

      await this.client.chat.postMessage({
        channel,
        thread_ts: results.messageTs, // Reply in thread
        text: `Failed Tests:\n\n${failureDetails}`,
      });
    }
  }
}

3. GitHub PR Comments

// github-reporter.ts
import { Octokit } from '@octokit/rest';

export class GitHubReporter {
  private octokit: Octokit;

  constructor(token: string) {
    this.octokit = new Octokit({ auth: token });
  }

  async commentOnPR(owner: string, repo: string, prNumber: number, results: TestResults) {
    const status = results.status === 'pass' ? '✅' : '❌';

    const body = `
## ${status} Test Results

| Metric | Value | Trend |
|--------|-------|-------|
| Pass Rate | ${results.passRate.toFixed(1)}% | ${this.getTrendEmoji(results.passRateTrend)} |
| Total Tests | ${results.totalTests} | ${this.getTrendEmoji(results.totalTestsTrend)} |
| Duration | ${formatDuration(results.duration)} | ${this.getTrendEmoji(results.durationTrend)} |

### Summary

- ✅ Passed: ${results.passedTests.length}
- ❌ Failed: ${results.failedTests.length}
- ⏭️ Skipped: ${results.skippedTests.length}

${
  results.failedTests.length > 0
    ? `
### Failed Tests

${results.failedTests
  .slice(0, 5)
  .map(
    (test) => `
<details>
<summary><code>${test.name}</code></summary>

\`\`\`
${test.error}
\`\`\`

[View Screenshot](${test.screenshotUrl})

</details>
`,
  )
  .join('\n')}

${results.failedTests.length > 5 ? `\n_...and ${results.failedTests.length - 5} more failures_` : ''}
`
    : ''
}


**Related articles:** Also see [velocity metrics that belong in every QA dashboard](/blog/measuring-qa-velocity-metrics), [observability data that complements test results in quality dashboards](/blog/monitoring-observability-qa), and [coverage metrics to surface in your reports alongside pass/fail data](/blog/code-coverage-metrics-guide).

---

[View Full Report](${process.env.DASHBOARD_URL}/runs/${results.id}) | [View Allure Report](${process.env.ALLURE_URL}/runs/${results.id})
    `;

    await this.octokit.issues.createComment({
      owner,
      repo,
      issue_number: prNumber,
      body,
    });
  }

  private getTrendEmoji(trend: number): string {
    if (trend > 5) return '📈';
    if (trend < -5) return '📉';
    return '➡️';
  }
}

Best Practices for Test Reporting

1. Automate Everything

Don't manually generate or send reports. Integrate reporting into your CI/CD pipeline.

2. Provide Multiple Detail Levels

• Executive summary: 1-page, high-level, actionable
• Manager summary: Trends, risks, team performance
• Engineer details: Stack traces, screenshots, reproduction steps

3. Make Reports Accessible

• Host dashboards on internal URL
• Ensure mobile-friendly
• Provide email/Slack notifications
• Archive reports for historical analysis

4. Include Context

• Compare to previous runs
• Show trends over time
• Link to related PRs/commits
• Reference known issues

5. Focus on Actions

Every report should answer "What should I do?"

Conclusion: Reports That Drive Decisions

Effective test reporting isn't about generating more data—it's about providing actionable intelligence that helps teams make better decisions faster.

Key takeaways:

• Know your audience - different stakeholders need different detail levels
• Show trends, not snapshots - context matters
• Automate distribution - integrate into CI/CD workflows
• Use visual dashboards - real-time visibility for everyone
• Implement Allure Reports - rich, detailed test documentation
• Track meaningful KPIs - metrics that drive improvement
• Make it actionable - always include "what to do next"

The best test report is the one that gets read, understood, and acted upon.

Ready to level up your test reporting? Start with ScanlyApp's intelligent reporting and dashboards and turn test data into actionable insights.