Dashboard

Welcome back, Alex

154
Uploads
299
Themes
196
PRDs
126
Tickets
8
Exported
Upload CSV
Import support tickets
Product Brain
Configure product context
Knowledge Graph
Explore entity relationships
Signal Sources
Manage integrations

Recent Uploads

View all
support-tickets-apr.csv Tickets Ready
Apr 1, 2026
Upload142
Themes6
PRDs4
Tickets2
Export0
zendesk-export-mar.csv Exported
Mar 18, 2026
Upload89
Themes4
PRDs4
Tickets4
Export4
intercom-tickets-feb.csv Exported
Feb 24, 2026
Upload67
Themes3
PRDs3
Tickets3
Export3
10-comprehensive-themes.csv PRDs Generated
Mar 21, 2026
Upload100
Themes20
PRDs12
Tickets—
Export—
sd_test_small.csv Tickets Ready
Mar 19, 2026
Upload5
Themes4
PRDs3
Tickets2
Export0
Recent Activity
Uploaded 10-comprehensive-the... Mar 21, 2026
Discovered 1 themes in 10-comp... Mar 21, 2026
Uploaded test-upload.csv (10 tick... Mar 21, 2026
Discovered 6 themes in test-uplo... Mar 21, 2026
Generated 4 PRDs for test-uplo... Mar 21, 2026
Created 4 ticket sets for test-uplo... Mar 21, 2026
Exported 1 ticket sets from test-u... Mar 21, 2026
Uploaded sample-tickets (5).csv (... Mar 21, 2026
Discovered 2 themes in sample-ti... Mar 21, 2026
Generated 2 PRDs for sample-tic... Mar 21, 2026

Upload Ticket CSV

Drop your support ticket export and we'll detect the columns automatically

Drop your CSV file here

or click to browse · Max 500 tickets

Themes Workspace

support-tickets-apr.csv · 142 tickets · 6 themes discovered

Evolution Intelligence

Compared with zendesk-export-mar.csv: 3 themes reinforced, 2 expanded scope, 1 entirely new signal.

6
Total Themes
4
PRDs Created
2
Ticket Sets
1
Exported
92
Authentication & SSO Failures
Enterprise users experiencing SAML/OAuth failures, locked accounts, and SSO timeout issues across multiple identity providers.
12 tickets Reinforced Exported
SSO login failing for Okta users
SAML response invalid after IdP update
Account locked after password reset
87
Performance & Page Load Degradation
Dashboard and project views loading slowly for users with large datasets. Affects Pro and Enterprise plans primarily.
9 tickets Expanded Ready for Export
81
Search & Indexing Gaps
Search results missing recent documents and filtering not returning expected results for tagged content.
7 tickets Reinforced Needs Tickets
Related Theme Detected: 85% overlap with "Performance & Page Load Degradation" — Consider merging before generating tickets.
74
Mobile App Stability
iOS crashes on launch, Android notification failures, and offline sync issues reported across multiple device types.
6 tickets New Needs PRD
68
Notification Delivery Failures
Email and in-app notifications not arriving for mentions, assignments, and deadline reminders.
5 tickets Reinforced Needs PRD
55
Integration & API Rate Limits
API rate limits too restrictive for enterprise sync workflows. Calendar and Google integrations requested.
4 tickets Expanded Needs PRD
Step 2 of 6

PRD: Performance & Page Load Degradation

Generated from 9 support tickets · Impact Score: 87

82
Score

High Confidence

Coverage: 82% · Missing: tracking events details

Expanded Theme

New customer signals expand this theme beyond previous scope. Previous cluster focused on dashboard loading; new signals include project views and API response times.

Generated with gpt-4o-mini · Product Brain context applied
  • Enterprise account admins managing 50+ projects
  • Pro users with large team workspaces
  • API consumers syncing data via integrations
  • Load dashboard within 2 seconds regardless of project count
  • Navigate between project views without perceptible delay
  • Sync data via API without hitting rate limit errors

As an enterprise admin, I want the dashboard to load within 2s so I can quickly check team status

AC: Dashboard renders complete metrics within 2000ms for accounts with up to 200 projects
AC: Loading skeleton shown within 200ms while data fetches

As a Pro user, I want project list pagination so large workspaces remain fast

AC: Project list paginates at 25 items with infinite scroll
AC: Search/filter operates on server-side query, not client-side
  • P95 dashboard load time < 2000ms (current: ~10,000ms)
  • API response P95 < 500ms for list endpoints
  • Zero 429 rate limit errors for standard sync patterns
dashboard_loaded
On complete render
project_list_paginated
On page change
api_rate_limit_hit
On 429 response
Step 3 of 6

Ticket Set: Performance & Page Load

Epic + 4 Issues generated from PRD

91
Score

High Confidence — Ready for export

Coverage: 91% · NFR keywords matched: performance, scalability, monitoring

EPIC

Performance & Page Load Optimization

Reduce dashboard load times from 10s to <2s, implement server-side pagination for project lists, and optimize API response times to eliminate rate limit errors for standard sync patterns.

Issue 1: Implement dashboard query optimization and caching

Add Redis caching layer for dashboard metrics. Implement incremental data loading with skeleton UI. Target: P95 load time <2000ms.

Acceptance Criteria:

  • Dashboard metrics cached with 5-minute TTL
  • Skeleton UI renders within 200ms
  • P95 load time < 2000ms verified via Datadog
performance backend high-priority

Issue 2: Add server-side pagination for project list views

Replace client-side filtering with server-side query. Implement cursor-based pagination with 25 items per page and infinite scroll UI.

Acceptance Criteria:

  • Project list paginates at 25 items with cursor-based API
  • Search and filter operate server-side
  • Smooth infinite scroll with loading indicators
frontend backend

Issue 3: Increase API rate limits and add adaptive throttling

Raise default rate limits for Enterprise plans. Implement token bucket algorithm with burst allowance. Add rate limit headers to all API responses.

QA Checklist:

  • Verify 429 responses include Retry-After header
  • Load test: 500 req/min for Enterprise tier
  • Verify rate limit headers (X-RateLimit-*) present
backend api

Issue 4: Add performance monitoring dashboard and alerting

Set up Datadog dashboards for P50/P95/P99 latencies. Configure PagerDuty alerts for P95 > 3000ms. Add tracking events for key user flows.

monitoring devops
Step 4 of 6

MPRDs: Performance & Page Load Optimization

Agent-optimized engineering briefs for each issue

Performance & Page Load Optimization

Epic with 4 issues · Generated from PRD

4
MPRDs Ready
2
Solutions Ready
Issue 1: Implement dashboard query optimization and caching
critical medium
Add Redis caching layer for dashboard metrics with skeleton UI. Reduce P95 load time from 10s to <2s, directly addressing the #1 user complaint by volume.
3 components 4 steps 4 tests
Has Solution
Solution Design

Approach: Introduce a Redis caching layer between the dashboard API and database. Cache dashboard metrics with a 5-minute TTL. Implement skeleton UI for instant perceived load while data fetches in the background.

Components:

RedisCache service
Cache manager wrapping ioredis with TTL-based get/set, invalidation, and connection pooling
DashboardMetrics api_endpoint
GET /api/dashboard/metrics — returns cached aggregate stats, falls through to DB on cache miss
SkeletonDashboard ui_component
Animated placeholder rendering within 200ms while metrics load asynchronously

Data Flow: Browser → SkeletonDashboard (instant) → GET /api/dashboard/metrics → RedisCache.get() → [hit: return cached] / [miss: query DB → RedisCache.set(ttl=300) → return]

Implementation Steps
1
Set up Redis connection and cache service
Add ioredis dependency, create lib/cache.ts with get/set/invalidate methods, configure connection pool from DATABASE_REDIS_URL env var
2
Refactor dashboard API to use cache layer
Wrap existing DB queries in cache-aside pattern. Generate cache key from userId + time bucket. Set 5-minute TTL. depends on: step 1
3
Build SkeletonDashboard component
Create animated placeholders for each metric card and chart area. Use Tailwind animate-pulse. Render immediately before data arrives.
4
Add cache invalidation on data changes
Invalidate relevant cache keys when uploads complete or tickets are modified. depends on: step 2

Constraints: Must not exceed 50MB Redis memory per tenant · TTL must be configurable via env var · Graceful fallback if Redis is unavailable

Verification

Acceptance Tests:

Dashboard loads within 2 seconds
Given a user with 500+ tickets across 10 uploads
When they navigate to the dashboard
Then skeleton UI renders within 200ms and full data appears within 2000ms
Cache invalidation on new upload
Given cached dashboard metrics for a user
When a new CSV upload completes processing
Then the next dashboard load reflects updated ticket counts and theme totals

Edge Case Tests:

Redis connection failure
Dashboard falls back to direct DB queries with degraded (but functional) performance. Error logged but not shown to user.
Concurrent cache writes during invalidation
Use atomic SET-IF-NOT-EXISTS with version stamps to prevent stale data from overwriting fresh invalidation.
Agent Context

Codebase Search Queries:

dashboard metrics API route handler
existing caching patterns or Redis config
skeleton UI or loading state components

Gotchas:

Multi-tenant cache keys must include userId to prevent data leakage between tenants
Existing auth middleware uses withAuth() wrapper — cache layer must run after authentication
Issue 2: Add server-side pagination for project list views
high medium
Replace client-side filtering with cursor-based server-side pagination. Implement infinite scroll UI with 25 items per page.
4 components 5 steps 3 tests
Has Solution
Issue 3: Increase API rate limits and add adaptive throttling
high small
Implement token bucket algorithm with burst allowance. Raise default rate limits for Enterprise tier. Add standard rate limit headers to all API responses.
2 components 3 steps 3 tests
Issue 4: Add performance monitoring dashboard and alerting
medium small
Set up Datadog dashboards for P50/P95/P99 latencies. Configure PagerDuty alerts for P95 > 3000ms. Add tracking events for key user flows.
2 components 3 steps 2 tests
Step 5 of 6

Solution: Dashboard Query Optimization and Caching

Detailed technical solution document for Issue 1

gpt-4o-mini
Generated 2 minutes ago
Executive Summary
This solution introduces a Redis-backed caching layer for dashboard metrics to reduce P95 load times from ~10 seconds to under 2 seconds. The approach uses a cache-aside pattern with 5-minute TTL, paired with a skeleton UI that provides instant visual feedback. Cache invalidation is triggered automatically when uploads complete or ticket data changes, ensuring data freshness without sacrificing performance.
Architecture
The caching layer sits between the Next.js API route handlers and the Prisma ORM database queries. Redis serves as a distributed cache shared across serverless function instances, with cache keys namespaced by userId for multi-tenant isolation.
Browser (React) ↓ GET /api/dashboard/metrics Next.js API Handler (withAuth) ↓ RedisCache.get(key) ↓ [HIT] → return cached JSON ↓ [MISS] → Prisma queries → aggregate → RedisCache.set(key, data, ttl=300) → return

Affected Areas:

new
lib/cache.ts
New Redis cache service with connection pooling and typed get/set methods
modify
app/api/dashboard/route.ts
Add cache-aside pattern around existing metric aggregation queries
extend
components/DashboardMetrics.tsx
Add SkeletonDashboard component and loading state management
Components
RedisCache service

Cache manager wrapping ioredis with typed get/set, TTL management, invalidation, and connection health checks

get<T>
async get<T>(key: string): Promise<T | null>
Retrieve cached value by key, returns null on miss or connection error
set
async set(key: string, value: unknown, ttlSeconds?: number): Promise<void>
Store value with optional TTL override (default: 300s)
Algorithm: Cache-aside with TTL expiry. Keys follow pattern dashboard:{userId}:{metricType}.
State: Connection pool managed by ioredis with lazy initialization and automatic reconnect.
DashboardMetricsHandler api_endpoint

Modified API handler that checks cache before querying the database

GET
GET /api/dashboard/metrics?range=7d|30d|90d
Returns aggregated ticket counts, theme counts, upload stats, and trend data
Algorithm: 1) Build cache key from userId + range param. 2) Attempt cache read. 3) On miss: run Prisma aggregation queries, write result to cache, return. 4) On hit: return cached JSON directly.
SkeletonDashboard ui_component

Animated loading placeholder that mirrors the dashboard layout

SkeletonDashboard
React.FC<{ columns?: number }>
Renders pulsing placeholder blocks matching metric cards and chart areas
Algorithm: Pure presentational component using Tailwind animate-pulse on gray rectangles. No data dependencies — renders instantly.
State: None. Parent component swaps skeleton for real data via conditional rendering.
Database Changes

Migrations:

Add composite index for dashboard aggregation queries
ALTER TABLE "Ticket" ADD INDEX idx_ticket_upload_created ON ("uploadId", "createdAt" DESC); ALTER TABLE "Upload" ADD INDEX idx_upload_user_created ON ("userId", "createdAt" DESC);

No data migration required — index-only change

Optimized Queries:

Dashboard metrics aggregation
Combines ticket count, theme count, upload count, and recent activity into a single optimized query using Prisma $transaction for consistent reads. Uses new composite indexes for O(log n) lookups.
API Contracts
GET /api/dashboard/metrics Auth Required
Returns cached dashboard metrics including ticket counts, theme distribution, upload history, and trend data. Supports ?range=7d|30d|90d query parameter.
Response: { totalTickets, totalThemes, totalUploads, recentActivity[], trends }
Errors: 401 Unauthorized · 429 Rate Limited · 500 Internal Error
POST /api/cache/invalidate Auth Required
Invalidates dashboard cache for the authenticated user. Called automatically after upload processing completes or ticket data is modified.
Request: { patterns: string[] }
Response: { invalidated: number }
Errors: 401 Unauthorized · 400 Invalid pattern
Implementation Plan
Phase 1: Cache Infrastructure ~4 hours
1. Add ioredis dependency and configure connection from env var
2. Implement RedisCache service with get/set/invalidate methods
3. Add connection health check and graceful fallback
4. Write unit tests for cache service (hit, miss, TTL, fallback)
Deliverable: Working cache service with 90%+ test coverage
Phase 2: Dashboard Integration ~6 hours
1. Refactor dashboard API handler to use cache-aside pattern
2. Add database indexes for optimized aggregation queries
3. Build SkeletonDashboard component with pulse animations
4. Add automatic cache invalidation on upload/ticket changes
5. Integration test: end-to-end with cache hit/miss scenarios
Deliverable: Dashboard loads in <2s with skeleton UI and cache warming

Risks:

medium
Redis availability in serverless environment
Mitigation: Implement graceful fallback to direct DB queries. Use Upstash Redis for serverless-native connection handling.
low
Stale data visible after cache invalidation race condition
Mitigation: Use version-stamped cache keys. Worst case: user sees data up to 5 minutes old (TTL window).
Testing Strategy

Unit Tests:

RedisCache Service
get() — returns cached value when key exists
get() — returns null on cache miss
set() — stores value with correct TTL
get() — returns null and logs error when Redis is unavailable
DashboardMetricsHandler
GET — returns cached metrics on cache hit (no DB query)
GET — queries DB and populates cache on cache miss
GET — falls back to DB when cache service throws

Integration Tests:

Cache invalidation flow
Scenario: Upload CSV → processing completes → cache invalidated → next dashboard load reflects new data
Steps: 1) Seed dashboard cache 2) Trigger upload processing 3) Verify cache key deleted 4) Verify next GET returns fresh data
Expected: Dashboard shows updated ticket and theme counts within one request after upload
Non-Functional Requirements
Performance P95 dashboard load time < 2000ms. Skeleton UI visible within 200ms. Cache hit latency < 50ms.
Monitoring Log cache hit/miss ratio per tenant. Alert on cache hit rate dropping below 80%. Track Redis connection health via Datadog.
Scalability Redis memory usage < 50MB per tenant. Cache keys auto-expire via TTL. No manual cleanup required.
Security Cache keys namespaced by userId. No cross-tenant data leakage possible. Redis connection encrypted via TLS.

Successfully Exported to Linear!

1 Epic, 4 Issues, 4 MPRDs, and 2 Solutions have been created in your Linear workspace.

Created Issues

Epic Performance & Page Load Optimization
Issue Implement dashboard query optimization and caching
Issue Add server-side pagination for project list views
Issue Increase API rate limits and add adaptive throttling
Issue Add performance monitoring dashboard and alerting

Attached Engineering Briefs & Solutions

MPRD Dashboard query optimization and caching + Solution
MPRD Server-side pagination for project lists + Solution
MPRD API rate limits and adaptive throttling
MPRD Performance monitoring dashboard and alerting

My Org

Configure your organization's Product Brain context

Nexus Support Platform

Active v1 SaaS

Enterprise-grade support ticket management platform with real-time collaboration, AI-powered routing, and multi-channel intake. Serves 2,500+ B2B customers across SaaS, fintech, and e-commerce verticals.

Target Customers: B2B Enterprise SMB Mid-Market
Release: Bi-weekly sprints, monthly releases A11y: WCAG 2.1 AA Architecture: Monolith (modular)

Product Context

Workflows
NamePriStatus
Ticket Intake & Routing1000
Ticket Resolution Pipeli...950
Authentication & Acces...900
Integration Sync Engine800
Reporting & Analytics750
User Onboarding700
Search & Discovery650
Business Rules
Business Logic
  • • All tickets must receive an initial response with...
  • • Ticket merging requires at least 80% similarit...
Authorization
  • • Enterprise customers get dedicated support q...
  • • Session timeout: 30 minutes idle, 14 days abs...
Compliance
  • • PII must be redacted from ticket descriptions ...
  • • OAuth tokens and API keys must be AES-256 ...
Validation
  • • All API endpoints must validate input against ...
Pricing
  • • Pro plan: 500 tickets/month, 5 integrations. E...

Tech Stack

Frontend:Next.js 16 (App Router)
Backend:Next.js API Routes + Node.js
Database:PostgreSQL 16, Redis (caching)
Auth:Custom (bcrypt + UUID sessions, SSO via SAML/OAuth)
Hosting:Render
Languages:TypeScript, SQL
Branching:GitHub Flow (feature branches → main)
Repo Notes: Monorepo: app/ (Next.js pages), lib/ (business logic), components/ (React UI), prisma/ (schema + migrations). Path alias @/* maps to project root.

Teams

Auth & SecurityENGINEERING
SlackJira
Customer SupportSUPPORT
Slack
Data & AnalyticsDATA
SlackJira
Design SystemsDESIGN
Slack
DevOps & InfrastructureDEVOPS
SlackJira
Frontend ExperienceENGINEERING
SlackJira
IntegrationsENGINEERING
SlackJira
Platform CoreENGINEERING
SlackJira
Product ManagementPRODUCT
Slack
QA & ReliabilityQA
SlackJira

Knowledge Graph

All themes mapped to your product architecture

8
Features
12
Themes
5
Teams
3
Uploads
298
Total Tickets
User Authentication Auth & Security
4 themes42 tickets
Password Reset Failures on MobileCritical
18 tickets
SSO Configuration ConfusionHigh
12 tickets
Session Timeout Too Aggressive
7 tickets
MFA Enrollment Friction
5 tickets
Dashboard & Analytics Frontend Experience
3 themes31 tickets
Dashboard Load Time ComplaintsHigh
14 tickets
Chart Export Missing Formats
10 tickets
Custom Date Range Picker Bugs
7 tickets
API & Integrations Platform Core
3 themes28 tickets
Webhook Delivery FailuresCritical
12 tickets
Rate Limiting Not Documented
9 tickets
OAuth Scope Confusion
7 tickets
Search & Filtering Frontend Experience
2 themes19 tickets
Full-Text Search Returns Irrelevant Results
11 tickets
Saved Filters Not Persisting
8 tickets
User Onboarding Customer Support
2 themes15 tickets
Setup Wizard Drop-off at Step 3
9 tickets
First Upload Empty State Confusing
6 tickets

Unmapped Themes

2 themes need mapping
Email Notification Delays
7 tickets
Mobile Push Notification Opt-out
5 tickets

Product Intelligence

AI-powered priority recommendations based on your support signal data

Insights up to date — generated 2h ago
Portfolio Briefing

Q2 Priority Shift

Authentication and onboarding friction are now your top-volume signal clusters. Performance complaints decreased 18% this cycle — focus engineering capacity on the new user journey.

Top Risk: Auth Failures Top Risk: Onboarding Drop-off Cross-Feature: Permission model confusion Cross-Feature: Mobile vs Web parity gap

Trend Analysis

Rising3
Falling1
Stable6
New2

Hotspots

SSO Login Failures38
Onboarding Wizard Errors27
CSV Export Timeout19
1
Critical

SSO Login Failures Spiking

38 tickets this cycle — 142% increase from last period. Enterprise customers reporting intermittent SAML assertion failures during peak hours.

Recommendation: Prioritize auth service audit before next release cycle.

2
High

Onboarding Wizard Drop-off

27 tickets — new users abandoning setup at step 3 (team invite). Multiple reports of email delivery failure for invite links.

Recommendation: Fix invite email delivery and add progress persistence to wizard.

Reasoning Engine

AI pipeline runs and generated artifacts

7
Total Runs
1
Active
23
Artifacts
87%
Avg Confidence
Recent Runs
Run #a1b2c3
Complete · 142 issues · 6 artifacts
Run #d4e5f6
Analyzing · 89 issues so far
Run #g7h8i9
Complete · 67 issues · 4 artifacts

Run #a1b2c3

Complete
142
Normalized Issues
6
Artifacts
18
Evidence Items

Generated Artifacts

Auth Service PRD
Product Requirements Document · 8 sections
94% confidence
Onboarding Ticket Set
Epic + 7 issues · Linear-ready
88% confidence

Signal Sources

Connected integrations and webhook endpoints

3
Total Sources
298
Total Signals
2h ago
Last Sync
Zendesk Productionzendesk
142 signals · Last sync 2h ago
Intercom Supportintercom
89 signals · Last sync 1d ago
Webhook Endpointwebhook
67 signals · https://app.signaldesk.io/webhooks/ingest/abc123

Guide

Everything you need to know about using SignalDesk

What is SignalDesk?

SignalDesk transforms your support ticket exports into prioritized product themes, structured PRDs, and engineering-ready tickets. Instead of manually reading through hundreds of tickets to spot patterns, SignalDesk uses AI to cluster similar issues, surface the themes that matter most, and generate actionable work items you can push directly to Linear or Jira.

The Pipeline

Every upload flows through a 5-stage pipeline. Each stage builds on the previous one, and you can review, edit, and refine the output at every step.

1. Upload
2. Themes
3. PRDs
4. Tickets
5. Export

Upload & Map Columns

What it does: Drag and drop a CSV export from your support tool — Zendesk, Intercom, Freshdesk, or anything else. SignalDesk auto-detects your columns using synonym-based matching.

Why it matters: Flexible column mapping means any ticket export works out of the box. No reformatting needed.

Required fields:

ticket_id, created_at, subject, description

Optional:

tags, priority, customer_plan — enriches clustering quality

Max 500 tickets per upload. Column names are flexible — "Title" maps to "subject", "Body" maps to "description", etc.

Clustering & Themes

What it does: AI generates semantic embeddings for each ticket, then clusters similar ones. Each cluster becomes a "theme" with a name, summary, and priority ranking.

Why it matters: Instead of manually tagging tickets, clustering reveals patterns across hundreds of requests. A theme like "Users can't reset passwords on mobile" might surface from 47 different tickets describing the same root problem.

How it works: Tickets are compared using cosine similarity on their embeddings. Similar tickets (above the threshold) get grouped. Each cluster needs at least 3 tickets to become a theme.

PRD Generation

What it does: Each theme is transformed into a structured 10-section PRD including problem statement, user stories, requirements, and success metrics — all grounded in ticket evidence.

Why it matters: Writing PRDs from scratch takes hours. SignalDesk generates a first draft in seconds, pre-filled with real customer language.

Product Brain boost: If you've configured Product Brain, it's injected into every PRD generation — referencing your actual tech stack, conventions, and terminology.

Ticket Generation

What it does: Each PRD is broken into an Epic with individual Issues — complete with titles, descriptions, acceptance criteria, and labels. Each ticket set gets a readiness score.

Readiness scores:

High — Clear scope, acceptance criteria, no ambiguity Medium — Good starting point, may need refinement Low — Needs review before assigning to a developer

Export

What it does: Push generated ticket sets directly to Linear or Jira via OAuth. The Epic becomes a project/epic in your tracker with all metadata preserved.

Why it matters: Zero copy-paste. Connect once, then export with one click. Your engineering team gets tickets in the tool they already use.

Product Brain

Product Brain is your product context — it tells SignalDesk about your product, tech stack, team structure, and engineering standards. When configured, this context is injected into every AI-powered step.

Product Brain includes:

  • • Product context — what your product does, who it's for
  • • Architecture & code — tech stack, repo structure, services
  • • Data & observability — databases, monitoring, key metrics
  • • Standards & teams — coding conventions, team ownership
  • • Feature catalog — existing features and their status

AI & API Keys

SignalDesk uses AI models for embeddings, clustering, PRDs, and ticket generation. You bring your own API key (BYOK) — your data goes directly to the provider.

Supported providers:

  • • OpenAI — GPT-4o, GPT-4o-mini (recommended)
  • • Anthropic — Claude models
  • • Google — Gemini models
  • • Moonshot — Kimi models

Keys are encrypted at rest using AES-256-GCM.

Tips & Best Practices

Prepare your CSV

Include rich descriptions for better clustering. Remove internal notes or agent replies — customer-facing content works best.

Right-size your uploads

50–500 tickets is the sweet spot. Too few and patterns won't emerge. Too many and themes become broad.

Review before exporting

AI-generated PRDs and tickets are strong first drafts. Review themes, edit PRD sections, and refine acceptance criteria before pushing to your tracker.

Re-upload to track evolution

Upload new batches periodically. SignalDesk compares themes across uploads so you can see which issues are growing, resolved, or new.

Set up Product Brain early

Even a basic Product Brain configuration significantly improves output quality. Start with your product name, tech stack, and team structure.

Product Brain Settings

Manage your product intelligence context

Product Context

Edit
Product Name: Acme SaaS
Description: Enterprise SaaS platform for team collaboration and project management.
Primary Users: Enterprise teams
Core Workflows: OnboardingBillingSupport
Key Business Rules: Tenant isolationGDPR compliant

Architecture & Code

Edit
Frontend: React / Next.js
Backend: Node.js
Database: PostgreSQL
Auth: Auth0
Hosting: AWS
Languages: TypeScript

Data & Observability

Edit
Error Tracking: Sentry
APM: Datadog
Feature Flags: LaunchDarkly
Data Warehouse: BigQuery

Engineering Standards

Edit
Performance: P95 < 200ms
Security: SOC 2 Type II
Testing: > 80% coverage
SLA: 99.9% uptime

Team Ownership

Edit
Security
4 members
Frontend
6 members
Platform
5 members

Enjoying the demo?

Drop your email and we'll send you a personalized walkthrough of how SignalDesk fits your team's workflow.

Continue exploring the demo