Skip to main content
Toots is evolving from a project management tool into a full product discovery platform. The roadmap features below are planned — they represent the pivot toward helping teams figure out what to build based on real customer evidence.
These features are not yet implemented. This page documents the planned product direction. See the GitHub Issues for implementation progress.

​
The vision

Most AI tools help you write code faster. But the hardest part of building products isn’t how to build — it’s what to build in the first place. Toots aims to close that gap by:
  1. Ingesting real customer data — Interviews, support tickets, analytics, feedback
  2. Surfacing insights — AI synthesizes patterns across your data
  3. Recommending features — Evidence-ranked proposals with citations
  4. Generating tickets — Jira/Linear-style issues grounded in evidence
Think of it as “Cursor for product management” — an AI system focused on helping teams decide what to build, not just how to build it.

​
Planned features

​
Data source ingestion

Upload or paste customer feedback to build your knowledge base:
  • Customer interviews — Transcripts from user research sessions
  • Support tickets — Issues from Zendesk, Intercom, or other tools
  • Survey results — Responses from NPS, CSAT, or custom surveys
  • Product analytics — Events and behavior from PostHog, Mixpanel, etc.
  • User feedback — Feature requests, bug reports, in-app feedback
The system will parse and chunk text for AI analysis, preparing it for embedding and retrieval.

​
Knowledge base with embeddings

Store all ingested data in PostgreSQL with pgvector for semantic search: 
model DataSource {
  id          String   @id @default(cuid())
  userId      String
  type        String   // "interview", "support", "survey", "analytics", "feedback"
  title       String
  content     String
  metadata    Json
  embedding   Vector   // pgvector for semantic similarity
  createdAt   DateTime @default(now())
}
This enables the AI to search across all your customer data when analyzing insights or generating recommendations.

​
Insight extraction

AI analyzes uploaded data to extract:
  • Themes — Common patterns across multiple data sources
  • Pain points — Specific problems users mention repeatedly
  • Feature requests — Explicit asks for new functionality
  • Opportunities — Unmet needs or workflow gaps
Each insight includes:
  • Evidence strength — Based on frequency and recency
  • Citations — Links back to source data (which interview, ticket, etc.)
  • Sentiment — Positive, negative, or neutral
  • User segments — Which customer types mention this

​
Insights dashboard

A dedicated view showing synthesized insights ranked by evidence: 
┌─────────────────────────────────────────────────────────────┐
│  Insights                              🔍 Search  📊 Filter  │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  🔴 High evidence (12 sources)                              │
│  Onboarding flow is confusing                               │
│  12/40 interviewees mentioned difficulty with initial setup │
│  📎 View sources  →  Create project                         │
│                                                              │
│  🟠 Medium evidence (6 sources)                             │
│  Export to CSV requested                                    │
│  6 support tickets and 3 feature requests                   │
│  📎 View sources  →  Create project                         │
│                                                              │
│  🟡 Low evidence (2 sources)                                │
│  Dark mode preference                                       │
│  Mentioned in 2 survey responses                            │
│  📎 View sources  →  Create project                         │
│                                                              │
└─────────────────────────────────────────────────────────────┘
Features:
  • Evidence ranking — Insights sorted by strength of evidence
  • Source links — Click to view original data (interview transcript, ticket, etc.)
  • One-click projects — Turn any insight into a project with tickets
  • Filters — By evidence strength, sentiment, user segment, or date range
  • Search — Find insights by keyword or theme

​
”What should we build?” mode

A new entry point alongside the existing “describe your project” flow: 
1. You have a project idea
2. Describe it to Toots
3. AI asks clarifying questions
4. AI generates tickets based on your idea
Instead of starting with an assumption about what to build, you start with what customers are telling you.

​
Insight → Project bridge

One click to turn an insight into a fully scoped project: 
Insight: "Onboarding flow is confusing (12 sources)"

↓ Click "Create project"

Project: "Improve user onboarding"
Description: "12/40 interviewees struggled with initial setup. 
              Common pain points: unclear CTAs, too many steps, 
              lack of progress indicators."

AI asks clarifying questions:
- What's your success metric (activation rate, time to value)?
- Who should be involved (designers, engineers, growth team)?
- What's your timeline?

AI generates tickets:
- "Analyze onboarding funnel data" (cites analytics source)
- "Review interview transcripts for specific friction points" (cites interview sources)
- "Design simplified onboarding flow" (references user feedback)
- "Implement progress indicator UI" (based on common request)
- etc.
Each ticket description includes citations:
“Users repeatedly mentioned confusion about next steps (see Interview #7, Interview #12, Support Ticket #45).”

​
Evidence-aware chat

When a project originates from an insight, the AI cites source data: 
You: "Why are we prioritizing the progress indicator?"

AI: "The progress indicator addresses a pain point mentioned in 8 interviews 
     (Interview #3, #7, #12, #18, #22, #29, #34, #38). Users described feeling 
     'lost' or 'unsure if they were doing it right' during onboarding."
     
     [View sources]
You can click “View sources” to see original interview transcripts, support tickets, or survey responses.

​
Data source integrations

Connect external tools to automatically ingest customer signals:
  • Intercom — Pull support conversations and user messages
  • PostHog — Import product analytics events and user behavior
  • Zendesk — Sync support tickets and customer feedback
  • Slack — Monitor channels for customer feedback and requests
  • Typeform — Import survey responses and NPS scores
  • Linear — Sync existing issues as data sources
Integrations run on a schedule (e.g., daily) to keep your knowledge base fresh.

​
Export to Jira/Linear

Once tickets are refined, export them to your team’s tool: 
Project: "Improve user onboarding" (8 tickets)

↓ Click "Export to Linear"

[OAuth flow]

Select Linear team: "Growth"
Map ticket types: Story → Story, Task → Task

✓ Exported 8 tickets to Linear
  View in Linear →
Export is one-way (Toots → Jira/Linear) to avoid sync conflicts. Toots remains the source of truth for evidence-backed planning; your team tool handles execution.

​
Coding agent handoff

Format ticket output for AI coding agents: 
{
  "ticket": {
    "title": "Implement progress indicator UI",
    "description": "Add a step-by-step progress indicator to the onboarding flow.",
    "acceptanceCriteria": [...],
    "evidence": [
      {"source": "Interview #7", "quote": "I had no idea how many steps were left"},
      {"source": "Interview #12", "quote": "Would love to see progress"},
    ]
  },
  "proposedChanges": {
    "ui": "Add a horizontal stepper component at the top of OnboardingFlow.tsx",
    "dataModel": "Track current_step in user onboarding state",
    "workflow": "Increment step on each 'Continue' button click"
  }
}
Copy this JSON and paste into Cursor, Claude Code, or another coding agent to implement with full context.

​
Architecture

The planned system architecture: 
┌─────────────────────────────────────────────────┐
│  Data Sources (input layer)                     │
│  ┌───────────┐ ┌──────────┐ ┌───────────────┐  │
│  │ Interviews│ │ Analytics│ │ Feedback /    │  │
│  │ & Notes   │ │ Events   │ │ Support       │  │
│  └─────┬─────┘ └────┬─────┘ └──────┬────────┘  │
│        └─────────────┼──────────────┘           │
│                      ▼                          │
│  Knowledge Base (embeddings + retrieval)        │
│  - pgvector for semantic search                 │
│  - Chunked and embedded customer data           │
│                      │                          │
│                      ▼                          │
│  Insight Engine ("what should we build?")       │
│  - Theme extraction                             │
│  - Pain point clustering                        │
│  - Evidence ranking                             │
│                      │                          │
│                      ▼                          │
│  Project + Ticket Generation                    │
│  - Chat with clarifying questions               │
│  - Tickets with citations                       │
│  - Kanban board                                 │
└─────────────────────────────────────────────────┘

​
Implementation progress

Follow along on GitHub:

GitHub Issues

See detailed tasks for each roadmap feature
The roadmap features are designed as self-contained, actionable issues. Contributions welcome!

​
Why this matters

Most product teams operate in two disconnected modes:
  1. Research mode — Talk to customers, analyze feedback, synthesize insights (manual, slow)
  2. Execution mode — Build features, ship code, track metrics (AI-assisted, fast)
There’s a gap between these modes. Research lives in docs and spreadsheets; tickets live in Jira or Linear. The connection between “customer said X” and “ticket to solve X” is manual and lossy. Toots aims to bridge that gap — making customer evidence the input to your roadmap, not just an artifact you reference occasionally.

​
Current vs. future

  • Email/password authentication
  • AI-generated tickets from project descriptions
  • Drag-and-drop Kanban board
  • Project chat to refine tickets
  • PostgreSQL persistence
  • Sidebar project list
The current features (v1) help you execute on ideas you already have. The roadmap features (v2) help you discover what to build in the first place.

​
Tech stack

Planned additions to support product discovery:
  • pgvector — PostgreSQL extension for vector embeddings
  • Embedding model — text-embedding-3-small or similar
  • Chunking strategy — Semantic chunking for long-form data
  • Retrieval — Hybrid search (semantic + keyword)
  • OAuth — For Intercom, Zendesk, Linear, etc.
  • Webhooks — For real-time data ingestion from integrations
The existing stack (Next.js, Prisma, Gemini, shadcn/ui) remains unchanged.

​
Next steps

AI ticket generation

Current feature: Generate tickets from ideas

Kanban board

Current feature: Visual ticket management

Project chat

Current feature: Refine tickets with AI

GitHub Issues

Track roadmap implementation progress

Build docs developers (and LLMs) love

Get started for freeTalk to us