---
# === IDENTITY ===
id: software/startup-dashboard/product-operations-dashboard/2026
canonical_question: "How do I build a product ops dashboard — feature tracking, user analytics, feedback management, release tracking?"
aliases:
  - "product operations dashboard setup"
  - "product analytics dashboard build"
  - "feature tracking dashboard implementation"
  - "startup product management dashboard"
entity_type: execution_recipe
domain: software > startup-dashboard > product-operations-dashboard
region: global
jurisdiction: global
temporal_scope: 2025-2026

# === VERIFICATION ===
last_verified: 2026-03-12
confidence: 0.88
version: 1.0
first_published: 2026-03-12

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: evolving
  last_breaking_change: "Mixpanel migrated to Warehouse-Native architecture (Q3 2025); Amplitude launched Session Replay GA (Q4 2025)"
  next_review: 2026-09-08
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Product analytics API rate limits: Mixpanel = 60 requests/hour (export), Amplitude = 360 requests/hour. Cache aggressively."
  - "Event tracking must be implemented before dashboard can show meaningful data — minimum 14 days of event collection required."
  - "User-level analytics require consent tracking under GDPR. Anonymous aggregates are safe; individual user journeys need consent."
  - "Feature flag status must match deployment state — stale flag data produces incorrect adoption metrics."
  - "Feedback volume under 50 items/month is too low for statistical significance — combine with qualitative analysis."

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs product strategy or roadmap planning, not a dashboard"
    use_instead: "Search knowledgelib.io for product strategy and roadmap planning — no dedicated unit yet"
  - condition: "User wants only analytics setup without a unified dashboard"
    use_instead: "software/landing-pages/analytics-implementation/2026"
  - condition: "User is building a customer-facing analytics product, not internal ops"
    use_instead: "Search knowledgelib.io for embedded customer-facing analytics — no dedicated unit yet"

# === AGENT HINTS ===
inputs_needed:
  - key: analytics_platform
    question: "Which product analytics tool does the team use?"
    type: choice
    options: ["Mixpanel", "Amplitude", "PostHog", "Pendo", "no analytics yet — auto-select"]
  - key: technical_skill
    question: "What is the user's technical skill level?"
    type: choice
    options: ["non-technical (no-code only)", "semi-technical (can edit code)", "developer (can write code)"]
  - key: budget_for_tools
    question: "What's the dashboard tool budget?"
    type: choice
    options: ["free tier only", "up to $50/month", "up to $200/month", "no limit"]
  - key: product_stage
    question: "What stage is the product?"
    type: choice
    options: ["pre-launch (no users)", "early (< 1,000 MAU)", "growing (1,000-50,000 MAU)", "scale (50,000+ MAU)"]

# === EXECUTION METADATA ===
execution:
  required_inputs:
    - name: "Product analytics account with API access"
      source: "user's analytics platform"
      format: "API key or service account"
    - name: "Project management tool access"
      source: "user's Jira, Linear, or GitHub Projects"
      format: "API token"
    - name: "Event tracking implementation"
      source: "engineering team"
      format: "SDK installed with core events firing"

  outputs:
    - name: "Product operations dashboard"
      format: "deployed web application"
      description: "Live dashboard showing feature adoption, user engagement metrics, feedback sentiment, sprint velocity, and release health"
    - name: "Data sync pipeline"
      format: "scheduled ETL jobs"
      description: "Automated extraction from analytics platform, project management tool, and feedback sources"

  tools_required:
    - name: "Retool or Metabase"
      purpose: "Dashboard UI builder"
      tier: "free"
      cost: "$0 (free tier) to $10/user/month"
      alternatives: ["Grafana", "Google Looker Studio", "Preset"]
    - name: "PostgreSQL"
      purpose: "Data warehouse for product metrics"
      tier: "free"
      cost: "$0 (Supabase free tier) to $25/month"
      alternatives: ["ClickHouse", "BigQuery", "DuckDB"]
    - name: "PostHog or Mixpanel"
      purpose: "Product analytics source"
      tier: "free"
      cost: "$0 (PostHog: 1M events/mo free) to $450/mo"
      alternatives: ["Amplitude", "Pendo", "Heap"]

  credentials_needed:
    - service: "Product analytics (Mixpanel/PostHog/Amplitude)"
      type: "API key or service account"
      where_to_get: "Platform Settings > Project Settings > API Keys"
      free_tier_limits: "Mixpanel: 20M events/mo; PostHog: 1M events/mo; Amplitude: 10M events/mo"
    - service: "Project management (Linear/Jira/GitHub)"
      type: "API token"
      where_to_get: "Settings > API > Personal Access Token"
      free_tier_limits: "Generally unlimited API access"

  estimated_duration: "5-8 hours for initial setup; 1-2 hours per additional data source"
  estimated_cost: "$0 (all free tiers) to $75/month (paid analytics + dashboard)"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/software/startup-dashboard/product-operations-dashboard/2026"
suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-03-12)"

# === RELATED UNITS ===
related_kos:
  depends_on:
    - id: "software/startup-dashboard/sales-operations-dashboard/2026"
      label: "Sales dashboard for feature request correlation"
  feeds_into:
    - id: "software/startup-dashboard/financial-operations-dashboard/2026"
      label: "Finance dashboard consumes product usage for unit economics"
  related_to:
    - id: "business/product-tech/product-metrics-benchmarks/2026"
      label: "Benchmark targets for product KPIs"

# === SOURCES ===
sources:
  - id: src1
    title: "Mixpanel API Documentation"
    author: Mixpanel
    url: https://docs.mixpanel.com/docs/quickstart/install-mixpanel
    type: official_docs
    published: 2025-11-01
    reliability: authoritative
  - id: src2
    title: "PostHog Product Analytics Documentation"
    author: PostHog
    url: https://posthog.com/docs
    type: official_docs
    published: 2025-12-01
    reliability: authoritative
  - id: src3
    title: "Product Management Dashboard Guide 2026"
    author: monday.com
    url: https://monday.com/blog/rnd/product-management-dashboard/
    type: industry_guide
    published: 2025-10-15
    reliability: high
  - id: src4
    title: "Best Product Analytics Tools 2026"
    author: Whatfix
    url: https://whatfix.com/blog/best-product-analytics-tools/
    type: industry_guide
    published: 2025-11-20
    reliability: high
  - id: src5
    title: "User Feedback Tools for Product Teams"
    author: Pendo
    url: https://www.pendo.io/pendo-blog/the-top-10-user-feedback-tools-in-2025/
    type: industry_guide
    published: 2025-09-15
    reliability: high
  - id: src6
    title: "How to Build an Actionable Product Analytics Dashboard"
    author: Contentsquare
    url: https://contentsquare.com/guides/product-analytics/dashboard/
    type: industry_guide
    published: 2025-10-01
    reliability: high
---

# Product Operations Dashboard

## Purpose

This recipe produces a product operations dashboard that tracks feature adoption and usage analytics, visualizes user engagement funnels, aggregates and categorizes user feedback, monitors sprint velocity and release health, and surfaces key product metrics (DAU/MAU, retention, activation rate). The output is a deployed internal tool giving the product team a unified view connecting what users do with why they do it and what the team is building next. [src6]

## Prerequisites
<!-- Agents: verify ALL prerequisites before executing. Missing prerequisites = failed execution. -->

- [ ] **Product analytics platform** with event tracking active — [PostHog](https://posthog.com) (free: 1M events/mo), [Mixpanel](https://mixpanel.com), or [Amplitude](https://amplitude.com)
- [ ] **Core events implemented** — at minimum: user_signup, feature_used, session_start, page_view, key_action_completed (14+ days of data)
- [ ] **Project management tool** with API access — [Linear](https://linear.app), [Jira](https://www.atlassian.com/software/jira), or [GitHub Projects](https://github.com/features/issues)
- [ ] **PostgreSQL database** — free tier at [Supabase](https://supabase.com) or [Neon](https://neon.tech)
- [ ] **Dashboard tool account** — [Retool](https://retool.com) or [Metabase](https://www.metabase.com)
- [ ] **Feedback collection channel** — in-app widget (Canny, UserVoice), support inbox, or structured Slack channel

## Constraints
<!-- Hard rules. Agents: enforce throughout execution. -->

- Product analytics API rate limits: Mixpanel export = 60 requests/hour, Amplitude = 360 requests/hour. Cache responses and batch queries. [src1]
- Minimum 14 days of event data required before dashboard metrics are meaningful. Feature adoption curves need 30+ days to stabilize.
- User-level analytics require GDPR consent. Anonymous aggregates are safe for operational dashboards; individual user journey views need consent tracking. [src2]
- Feature flag status must sync with deployment state. Stale flag data (e.g., flag shows "off" but feature is live) produces incorrect adoption metrics.
- Feedback volume under 50 items/month lacks statistical significance for trend analysis. Combine quantitative patterns with qualitative review.

## Tool Selection Decision

```
Which path?
├── User is non-technical AND budget = free
│   └── PATH A: No-Code Free — PostHog (built-in dashboards) + Google Sheets
├── User is non-technical AND budget > $0
│   └── PATH B: No-Code Paid — Mixpanel/Amplitude native + Retool
├── User is semi-technical or developer AND budget = free
│   └── PATH C: Code + Free — PostHog + Metabase + PostgreSQL + cron
└── User is developer AND budget > $0
    └── PATH D: Code + Paid — PostHog/Mixpanel + Retool + PostgreSQL + n8n
```

| Path | Tools | Cost | Speed | Output Quality |
|------|-------|------|-------|---------------|
| A: No-Code Free | PostHog dashboards + Google Sheets | $0 | 2-3 hours | Basic — limited cross-data-source views |
| B: No-Code Paid | Mixpanel/Amplitude + Retool | $0-50/mo | 4-6 hours | Good — native analytics + custom views |
| C: Code + Free | PostHog + Metabase + PostgreSQL | $0 | 6-8 hours | Good — full SQL, custom metrics |
| D: Code + Paid | PostHog/Mixpanel + Retool + PostgreSQL | $25-75/mo | 5-7 hours | Excellent — unified view, real-time |

## Execution Flow

### Step 1: Design the Product Data Model

**Duration**: 30-60 minutes
**Tool**: SQL client

```sql
-- Product operations data model
CREATE TABLE product_events (
  id SERIAL PRIMARY KEY,
  date DATE NOT NULL,
  event_name TEXT NOT NULL,
  user_count INTEGER DEFAULT 0,
  event_count INTEGER DEFAULT 0,
  unique_users INTEGER DEFAULT 0
);

CREATE TABLE feature_adoption (
  id SERIAL PRIMARY KEY,
  date DATE NOT NULL,
  feature_name TEXT NOT NULL,
  users_exposed INTEGER DEFAULT 0,
  users_activated INTEGER DEFAULT 0,
  users_retained_7d INTEGER DEFAULT 0,
  flag_status TEXT DEFAULT 'on' -- 'on', 'off', 'partial'
);

CREATE TABLE user_engagement (
  id SERIAL PRIMARY KEY,
  date DATE NOT NULL,
  dau INTEGER DEFAULT 0,
  wau INTEGER DEFAULT 0,
  mau INTEGER DEFAULT 0,
  sessions INTEGER DEFAULT 0,
  avg_session_duration NUMERIC(8,2) DEFAULT 0,
  retention_d1 NUMERIC(5,2) DEFAULT 0,
  retention_d7 NUMERIC(5,2) DEFAULT 0,
  retention_d30 NUMERIC(5,2) DEFAULT 0
);

CREATE TABLE user_feedback (
  id SERIAL PRIMARY KEY,
  submitted_at TIMESTAMPTZ DEFAULT NOW(),
  source TEXT NOT NULL, -- 'in-app', 'support', 'survey', 'social'
  category TEXT, -- 'bug', 'feature_request', 'ux_issue', 'praise'
  sentiment TEXT, -- 'positive', 'neutral', 'negative'
  feature_area TEXT,
  summary TEXT,
  raw_text TEXT,
  user_id TEXT,
  priority TEXT DEFAULT 'medium'
);

CREATE TABLE sprint_metrics (
  id SERIAL PRIMARY KEY,
  sprint_name TEXT NOT NULL,
  start_date DATE NOT NULL,
  end_date DATE NOT NULL,
  planned_points INTEGER DEFAULT 0,
  completed_points INTEGER DEFAULT 0,
  stories_planned INTEGER DEFAULT 0,
  stories_completed INTEGER DEFAULT 0,
  bugs_found INTEGER DEFAULT 0,
  bugs_fixed INTEGER DEFAULT 0
);

CREATE TABLE releases (
  id SERIAL PRIMARY KEY,
  version TEXT NOT NULL,
  release_date TIMESTAMPTZ NOT NULL,
  features_shipped INTEGER DEFAULT 0,
  bugs_fixed INTEGER DEFAULT 0,
  rollback BOOLEAN DEFAULT FALSE,
  error_rate_before NUMERIC(5,2),
  error_rate_after NUMERIC(5,2),
  notes TEXT
);

-- Indexes
CREATE INDEX idx_events_date ON product_events(date, event_name);
CREATE INDEX idx_adoption_date ON feature_adoption(date, feature_name);
CREATE INDEX idx_engagement_date ON user_engagement(date);
CREATE INDEX idx_feedback_date ON user_feedback(submitted_at);
CREATE INDEX idx_feedback_category ON user_feedback(category);
CREATE INDEX idx_sprint_date ON sprint_metrics(start_date);
CREATE INDEX idx_releases_date ON releases(release_date);
```

**Verify**: All 6 tables created. `\dt` shows them.
**If failed**: Check database permissions and connection.

### Step 2: Build Analytics Data Sync

**Duration**: 1-2 hours
**Tool**: n8n, custom script, or PostHog data export

For PostHog (recommended — open source):

```javascript
// PostHog API: GET https://app.posthog.com/api/projects/{project_id}/insights/trend/
// Headers: Authorization: Bearer {POSTHOG_API_KEY}
// Params: events=[{"id":"$pageview"},{"id":"user_signup"},{"id":"feature_used"}]
//         &date_from=-14d&interval=day

// Daily engagement metrics extraction
const engagementQuery = {
  url: `https://app.posthog.com/api/projects/${PROJECT_ID}/insights/trend/`,
  headers: { Authorization: `Bearer ${POSTHOG_KEY}` },
  params: {
    events: JSON.stringify([{ id: '$pageview', math: 'dau' }]),
    date_from: '-7d',
    interval: 'day'
  }
};

// Feature adoption extraction
const featureQuery = {
  url: `https://app.posthog.com/api/projects/${PROJECT_ID}/insights/funnel/`,
  headers: { Authorization: `Bearer ${POSTHOG_KEY}` },
  params: {
    events: JSON.stringify([
      { id: 'feature_exposed', properties: [{ key: 'feature_name', value: 'new_editor' }] },
      { id: 'feature_activated' },
      { id: 'feature_retained_7d' }
    ]),
    date_from: '-30d'
  }
};
```

For Linear (project management sync):

```javascript
// Linear GraphQL API
// POST https://api.linear.app/graphql
// Headers: Authorization: {LINEAR_API_KEY}
const query = `{
  cycles(filter: { completedAt: { gte: "${thirtyDaysAgo}" } }) {
    nodes {
      name
      startsAt
      endsAt
      progress
      issueCountHistory
      completedIssueCountHistory
      scopeHistory
      completedScopeHistory
    }
  }
}`;
```

**Expected output**: product_events and user_engagement populated with 14+ days of data.
**Verify**: `SELECT COUNT(DISTINCT date) FROM user_engagement;` returns >= 14.
**If failed**: Check API key permissions. PostHog requires "Read" scope on the project.

### Step 3: Build Product Analytics Queries

**Duration**: 1-2 hours
**Tool**: SQL

```sql
-- 1. Daily engagement metrics (DAU/WAU/MAU ratio)
SELECT
  date,
  dau,
  wau,
  mau,
  ROUND(dau::NUMERIC / NULLIF(mau, 0) * 100, 1) as dau_mau_ratio,
  ROUND(dau::NUMERIC / NULLIF(wau, 0) * 100, 1) as dau_wau_ratio,
  avg_session_duration,
  retention_d1,
  retention_d7
FROM user_engagement
WHERE date >= CURRENT_DATE - INTERVAL '30 days'
ORDER BY date;

-- 2. Feature adoption funnel
SELECT
  feature_name,
  SUM(users_exposed) as total_exposed,
  SUM(users_activated) as total_activated,
  SUM(users_retained_7d) as total_retained,
  ROUND(SUM(users_activated)::NUMERIC / NULLIF(SUM(users_exposed), 0) * 100, 1) as activation_rate,
  ROUND(SUM(users_retained_7d)::NUMERIC / NULLIF(SUM(users_activated), 0) * 100, 1) as retention_rate
FROM feature_adoption
WHERE date >= CURRENT_DATE - INTERVAL '30 days'
  AND flag_status = 'on'
GROUP BY feature_name
ORDER BY activation_rate DESC;

-- 3. Feedback category breakdown
SELECT
  category,
  COUNT(*) as count,
  COUNT(*) FILTER (WHERE sentiment = 'negative') as negative,
  COUNT(*) FILTER (WHERE sentiment = 'positive') as positive,
  ROUND(COUNT(*) FILTER (WHERE sentiment = 'negative')::NUMERIC / COUNT(*) * 100, 1) as negative_pct
FROM user_feedback
WHERE submitted_at >= NOW() - INTERVAL '30 days'
GROUP BY category
ORDER BY count DESC;

-- 4. Sprint velocity trend
SELECT
  sprint_name,
  start_date,
  planned_points,
  completed_points,
  ROUND(completed_points::NUMERIC / NULLIF(planned_points, 0) * 100, 1) as completion_rate,
  stories_completed,
  bugs_found,
  bugs_fixed
FROM sprint_metrics
ORDER BY start_date DESC
LIMIT 10;

-- 5. Release health
SELECT
  version,
  release_date,
  features_shipped,
  bugs_fixed,
  rollback,
  error_rate_before,
  error_rate_after,
  CASE
    WHEN error_rate_after > error_rate_before * 1.5 THEN 'degraded'
    WHEN rollback THEN 'rolled_back'
    ELSE 'healthy'
  END as health_status
FROM releases
ORDER BY release_date DESC
LIMIT 10;
```

**Verify**: All queries return data. Feature adoption query shows at least one feature.
**If failed**: Check feature_name consistency between analytics events and adoption table.

### Step 4: Assemble the Dashboard UI

**Duration**: 1-2 hours
**Tool**: Retool or Metabase

```
Dashboard Layout:
┌─────────────────────────────────────────────────────┐
│  KPI Row: DAU | DAU/MAU Ratio | D7 Retention |      │
│           Avg Session | NPS/Feedback Score           │
├─────────────────────────┬───────────────────────────┤
│  DAU/WAU/MAU Trend      │  Feature Adoption Funnel  │
│  (multi-line chart)     │  (horizontal bar)         │
├─────────────────────────┼───────────────────────────┤
│  Feedback Category      │  Sprint Velocity Trend    │
│  Breakdown (pie/bar)    │  (bar chart, 10 sprints)  │
├─────────────────────────┴───────────────────────────┤
│  Release Health Timeline (table with status badges)  │
├─────────────────────────────────────────────────────┤
│  Recent Feedback Feed (sortable, filterable)         │
└─────────────────────────────────────────────────────┘
```

Add filters: date range (7d, 30d, 90d), feature filter, feedback category filter.

**Verify**: All 6 sections render with data. DAU matches analytics platform within 5%.
**If failed**: Check query bindings and date parameter passing.

### Step 5: Configure Product Alerts

**Duration**: 30-60 minutes
**Tool**: n8n or Pipedream + Slack

```javascript
// Daily product health check (run at 8:00 AM)
const alerts = [];

// DAU drop > 20% from 7-day average
if (todayDAU < avgDAU7d * 0.8) {
  alerts.push(`DAU dropped ${Math.round((1 - todayDAU/avgDAU7d) * 100)}% vs 7-day avg`);
}

// Feature adoption below threshold
for (const feature of recentFeatures) {
  if (feature.activation_rate < 10 && feature.days_since_launch > 7) {
    alerts.push(`${feature.name}: ${feature.activation_rate}% adoption after ${feature.days_since_launch} days`);
  }
}

// Negative feedback spike
if (negativeCount > avgNegative7d * 2) {
  alerts.push(`Negative feedback spike: ${negativeCount} today vs ${Math.round(avgNegative7d)} avg`);
}

// Release error rate increase
if (latestRelease.error_rate_after > latestRelease.error_rate_before * 1.5) {
  alerts.push(`Release ${latestRelease.version}: error rate increased ${Math.round((latestRelease.error_rate_after / latestRelease.error_rate_before - 1) * 100)}%`);
}
```

**Verify**: Test alert fires in Slack with sample data.
**If failed**: Check Slack webhook URL and n8n workflow status.

### Step 6: Deploy and Share Access

**Duration**: 30 minutes
**Tool**: Dashboard platform settings

- Share dashboard URL with product team (PM, design, engineering leads)
- Set viewer permissions for engineers, editor for PMs
- Configure daily Slack digest of key metrics
- Create separate "Release Health" view for engineering on-call

**Verify**: Product manager and engineering lead can both access the dashboard.

## Output Schema

```json
{
  "output_type": "product_operations_dashboard",
  "format": "deployed web application",
  "components": [
    {"name": "engagement_trend", "type": "chart", "description": "DAU/WAU/MAU multi-line trend with ratio indicators", "required": true},
    {"name": "feature_adoption", "type": "chart", "description": "Feature-level adoption funnel: exposed → activated → retained", "required": true},
    {"name": "feedback_analysis", "type": "chart", "description": "Feedback breakdown by category and sentiment", "required": true},
    {"name": "sprint_velocity", "type": "chart", "description": "Sprint completion rate trend over last 10 sprints", "required": true},
    {"name": "release_health", "type": "table", "description": "Recent releases with error rate delta and health status", "required": true},
    {"name": "kpi_cards", "type": "metrics", "description": "DAU, DAU/MAU ratio, D7 retention, avg session, feedback score", "required": true}
  ],
  "refresh_interval": "30 minutes (analytics), 6 hours (sprint/release)",
  "data_source": "PostgreSQL synced from analytics platform and project management tool"
}
```

## Quality Benchmarks

| Quality Metric | Minimum Acceptable | Good | Excellent |
|---------------|-------------------|------|-----------|
| Data freshness (analytics) | < 24 hour lag | < 6 hour lag | < 1 hour lag |
| Event coverage | 5+ core events tracked | 10+ events | Full event taxonomy |
| Feature tracking | Manual feature list | Auto-detected from flags | Real-time flag sync |
| Feedback integration | 1 source (in-app) | 2-3 sources | All channels unified |
| Sprint data accuracy | Manual entry | API-synced weekly | Real-time from PM tool |

**If below minimum**: Check analytics SDK implementation. Missing events usually indicate SDK not initialized on all pages or event names misspelled.

## Error Handling

| Error | Likely Cause | Recovery Action |
|-------|-------------|----------------|
| Analytics API 429 (rate limit) | Too many export requests | Reduce query frequency, batch date ranges into fewer calls |
| DAU shows 0 | Analytics SDK not initialized or events blocked | Verify SDK installation, check ad blocker interference |
| Feature adoption shows 0% | Feature flag not synced or event name mismatch | Verify flag status in feature flag tool, check event naming |
| Sprint data missing | PM tool API token expired | Regenerate token in Linear/Jira settings |
| Feedback not appearing | Webhook or polling not configured | Check feedback tool webhook URL, verify API polling schedule |
| Release health shows all "degraded" | Error rate baseline not calibrated | Recalculate baseline from 7-day pre-release average |

## Cost Breakdown

| Component | Free Tier | Paid Tier | At Scale (50K+ MAU) |
|-----------|-----------|-----------|----------|
| Analytics (PostHog) | $0 (1M events/mo) | $450/mo (2M events) | Custom pricing |
| Dashboard (Retool) | $0 (5 users) | $10/user/mo | $100/mo (10 users) |
| Database (Supabase) | $0 (500MB) | $25/mo | $25/mo |
| ETL (n8n) | $0 (self-hosted) | $20/mo | $50/mo |
| **Total** | **$0** | **$505/mo** | **$625+/mo** |

## Anti-Patterns

### Wrong: Tracking vanity metrics without activation context
Showing DAU growth without connecting it to feature activation or retention creates false confidence. DAU can grow from marketing spend while the product itself fails to retain users. [src6]

### Correct: Always pair usage metrics with retention cohorts
Display DAU alongside D7 and D30 retention. A healthy product shows DAU growth AND stable/improving retention. If DAU grows but retention drops, the growth is unsustainable.

### Wrong: Aggregating all feedback into a single sentiment score
Averaging positive and negative feedback into one number hides critical signals. A score of "neutral" could mean "everything is fine" or "half the users love it and half hate it." [src5]

### Correct: Segment feedback by category and feature area
Show feedback broken down by category (bug, feature request, UX issue) and by feature area. Track trends over time within each segment, not across them.

## When This Matters

Use when a startup product team has active users and needs unified visibility into what users do, what they think, what the team is building, and how releases perform. Requires at least one analytics platform collecting events for 14+ days. This recipe builds the dashboard — for product strategy or roadmap planning, use a playbook card instead.

## Related Units

- [Sales Operations Dashboard](/software/startup-dashboard/sales-operations-dashboard/2026) — correlates feature requests with pipeline deals
- [Financial Operations Dashboard](/software/startup-dashboard/financial-operations-dashboard/2026) — consumes usage data for unit economics
- [Product Metrics Benchmarks](/business/product-tech/product-metrics-benchmarks/2026) — benchmark targets for DAU/MAU, retention