Software feature request processing and roadmap generation

Feature requests are arriving faster than ever, but your process for capturing them probably hasn't changed since 2015. Your team spends hours copying requests from emails, Slack messages, and support tickets into a spreadsheet. Someone reads through them, spots patterns, and manually writes up a roadmap. Rinse and repeat next quarter. For more on this, see Customer support ticket analysis and response automation.

This is where you're losing time: every request lands in a different place, nobody has a single source of truth, and generating actionable roadmap insights requires someone to actually read and categorise everything manually. By the time your roadmap is written, you've already wasted five hours that could have been spent shipping features.

What if you could capture feature requests from anywhere, automatically categorise and deduplicate them, analyse sentiment and demand signals, and generate a ranked roadmap—all without touching a spreadsheet? That's what this workflow does. We'll wire together Bhava AI for request capture, Mindpal for intelligent analysis and categorisation, and Terrakotta AI for roadmap generation. Everything flows automatically from request to roadmap.

The Automated Workflow

Architecture Overview

The workflow operates in three stages: ingestion, analysis, and output. Requests enter via a webhook, get processed through Bhava AI's classification engine, pass into Mindpal for clustering and deduplication, then feed into Terrakotta AI for roadmap generation. We'll use n8n as the orchestration platform because it offers the best native support for these three tools and gives you real-time visibility into each step.

Copy
Incoming Request (Email/Slack/Form)
         ↓
    Webhook (n8n)
         ↓
  Bhava AI Classification
         ↓
  Mindpal Analysis & Deduplication
         ↓
  Terrakotta AI Roadmap Generation
         ↓
  Output (Slack/Sheet/Email)

Step 1: Capturing Requests with a Webhook

Set up a webhook in n8n that accepts incoming feature requests from any source. You'll want this endpoint to be fairly flexible because requests will come from different channels: some from your support email, some from Slack, some from your feature request form.

Copy
[POST](/tools/post) /webhook/feature-requests
Content-Type: application/json

{
  "source": "slack",
  "requester_name": "Alice Chen",
  "requester_email": "alice@company.com",
  "request_text": "We need bulk export to CSV so we can run analytics on our data externally",
  "request_date": "2025-01-15T09:23:00Z",
  "priority_hint": "high",
  "customer_tier": "enterprise"
}

In n8n, create a Webhook trigger node. Configure it to accept POST requests and store the incoming JSON. This becomes your entry point; everything else flows from here.

Step 2: Classify with Bhava AI

Bhava AI specialises in extracting structured data from unstructured text. Feed it the request text and ask it to classify the request along several dimensions: feature category, priority level, affected user role, and whether this is a new request or a duplicate of something you've seen before.

Create an HTTP Request node in n8n that calls Bhava AI's classification API:

Copy
POST https://api.bhava-ai.com/v1/classify
Authorization: Bearer YOUR_BHAVA_API_KEY
Content-Type: application/json

{
  "text": "{{ $node['Webhook'].json['request_text'] }}",
  "classifications": [
    {
      "dimension": "feature_category",
      "options": ["Reporting", "Data Management", "Integration", "User Experience", "Performance", "Security", "Other"]
    },
    {
      "dimension": "priority_level",
      "options": ["Low", "Medium", "High", "Critical"]
    },
    {
      "dimension": "user_role",
      "options": ["Admin", "End User", "Developer", "Data Analyst", "Other"]
    },
    {
      "dimension": "duplicate_likelihood",
      "options": ["Unique", "Likely Duplicate", "Definite Duplicate"]
    }
  ],
  "context": "You are analysing feature requests for a data analytics platform. Be conservative with duplicate detection; only flag as duplicate if the request is essentially asking for the same thing as something common."
}

Bhava AI returns structured classifications. Extract these into variables you can use downstream:

Copy{
  "category": "Data Management",
  "priority": "High",
  "user_role": "End User",
  "duplicate_likelihood": "Unique",
  "confidence_scores": {
    "category": 0.92,
    "priority": 0.87,
    "user_role": 0.95,
    "duplicate": 0.31
  }
}

Map these results into a standardised format. If the duplicate likelihood is "Definite Duplicate", you can either skip it entirely or flag it for manual review later.

Step 3: Deduplication and Clustering with Mindpal

Before you generate a roadmap, you need to know what people are actually asking for. A hundred requests for "CSV export" should count as one item with high demand, not a hundred separate feature ideas. This is where Mindpal comes in. It clusters semantically similar requests and identifies demand signals.

Send the classified request (along with any previously stored requests) to Mindpal:

Copy
POST https://api.mindpal.io/v1/cluster
Authorization: Bearer YOUR_MINDPAL_API_KEY
Content-Type: application/json

{
  "requests": [
    {
      "id": "req_12345",
      "text": "We need bulk export to CSV so we can run analytics on our data externally",
      "category": "Data Management",
      "priority": "High",
      "user_role": "End User",
      "customer_tier": "enterprise",
      "timestamp": "2025-01-15T09:23:00Z"
    },
    {
      "id": "req_12344",
      "text": "Please add the ability to export all our records at once in CSV format",
      "category": "Data Management",
      "priority": "High",
      "user_role": "End User",
      "customer_tier": "mid-market",
      "timestamp": "2025-01-14T14:55:00Z"
    }
  ],
  "clustering_strategy": "semantic_with_category_filter",
  "min_cluster_size": 1,
  "return_demand_signals": true
}

Mindpal returns clustered requests with a demand score for each cluster:

Copy{
  "clusters": [
    {
      "cluster_id": "cluster_csv_export",
      "primary_request": "Bulk export to CSV",
      "member_count": 2,
      "member_ids": ["req_12345", "req_12344"],
      "demand_score": 8.5,
      "affected_tiers": ["enterprise", "mid-market"],
      "affected_roles": ["End User"],
      "earliest_request": "2025-01-14T14:55:00Z",
      "latest_request": "2025-01-15T09:23:00Z",
      "sentiment_summary": "positive_expectation"
    }
  ],
  "new_clusters_detected": 1
}

Store these clusters in a database (or Google Sheet via n8n's built-in connector). The key metric here is demand_score, which combines frequency, recency, customer tier, and sentiment.

Step 4: Generate Roadmap with Terrakotta AI

Once you have clustered requests with demand scores, feed them into Terrakotta AI for roadmap generation. Terrakotta specialises in synthesising multiple data points into prioritised, narrative-driven roadmaps.

Copy
POST https://api.terrakotta-ai.com/v1/generate-roadmap
Authorization: Bearer YOUR_TERRAKOTTA_API_KEY
Content-Type: application/json

{
  "feature_clusters": [
    {
      "cluster_id": "cluster_csv_export",
      "title": "Bulk export to CSV",
      "description": "Users want to export all records at once in CSV format for external analysis",
      "demand_score": 8.5,
      "affected_customer_count": 2,
      "affected_tiers": ["enterprise", "mid-market"],
      "first_requested": "2025-01-14",
      "sentiment": "positive_expectation",
      "related_features": []
    }
  ],
  "roadmap_horizon": "Q1-Q2",
  "prioritisation_weights": {
    "demand_score": 0.4,
    "customer_tier_distribution": 0.3,
    "strategic_alignment": 0.2,
    "implementation_effort": 0.1
  },
  "include_reasoning": true,
  "output_format": "structured_narrative"
}
```...... For more on this, see [Customer feedback analysis to product roadmap alignment w...](/blog/customer-feedback-analysis-to-product-roadmap-alignment-workflow). For more on this, see [Customer feedback analysis and product roadmap alignment](/blog/customer-feedback-analysis-and-product-roadmap-alignment).

Terrakotta returns a prioritised roadmap with explanations:

```json
{
  "roadmap": [
    {
      "rank": 1,
      "title": "Bulk CSV Export",
      "quarter": "Q1",
      "demand_score": 8.5,
      "priority_reasoning": "High demand from enterprise and mid-market customers with positive sentiment. Two separate requests within 24 hours indicates urgent need.",
      "estimated_effort": "medium",
      "customer_impact": "high",
      "strategic_fit": "enables_data_workflows"
    }
  ],
  "generated_at": "2025-01-15T10:00:00Z",
  "next_review_date": "2025-02-15"
}

Step 5: Output to Stakeholders

The final step sends your generated roadmap to the people who need it. Use n8n's connectors to push results to Slack, email, or a Google Sheet. You probably want both immediate notification (Slack) and persistent storage (Sheet).

Slack notification:

Copy
POST https://hooks.slack.com/services/YOUR_WEBHOOK_URL
Content-Type: application/json

{
  "text": "Feature Request Roadmap Updated",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*New Roadmap Generated*\n\nTop priority: Bulk CSV Export\nDemand score: 8.5/10\nEstimated effort: Medium\nQuarter: Q1"
      }
    },
    {
      "type": "actions",
      "elements": [
        {
          "type": "button",
          "text": {
            "type": "plain_text",
            "text": "View Full Roadmap"
          },
          "url": "{{ $node['Terrakotta'].json['roadmap_sheet_url'] }}"
        }
      ]
    }
  ]
}

Google Sheets append (for persistent tracking):

Copy
{
  "spreadsheet_id": "YOUR_SHEET_ID",
  "range": "Roadmap!A:H",
  "values": [
    [
      "{{ $node['Terrakotta'].json['roadmap'][0]['title'] }}",
      "{{ $node['Terrakotta'].json['roadmap'][0]['quarter'] }}",
      "{{ $node['Terrakotta'].json['roadmap'][0]['demand_score'] }}",
      "{{ $node['Terrakotta'].json['roadmap'][0]['estimated_effort'] }}",
      "{{ $node['Terrakotta'].json['roadmap'][0]['priority_reasoning'] }}",
      "{{ now().toFormat('yyyy-MM-dd') }}",
      "Active",
      "{{ $node['Webhook'].json['source'] }}"
    ]
  ]
}

This creates an auditable log. Every time the workflow runs, it appends a new row. Over time, you can see how priorities shift, how long features stay on the roadmap, and which requests actually made it into production.

The Manual Alternative

If you prefer more control, you can run this workflow in two modes: fully automatic or semi-automatic with checkpoints.

In semi-automatic mode, after Mindpal clusters the requests, send a Slack notification with approval buttons. Your product manager can review the clustering, adjust demand scores if needed, and explicitly approve the roadmap before it's published. This adds a review step but prevents any obviously wrong classifications from propagating downstream.

To implement this, add a conditional in n8n after the Mindpal step. If the workflow detects a new cluster or a demand score change above 3 points, it pauses and sends a Slack message with the top three most impacted clusters. Your PM clicks "Approve" or "Adjust", and the workflow continues.

You can also run this manually on demand. Instead of a webhook trigger, use a scheduled trigger (weekly or monthly) that pulls all feature requests from your database and processes them in batch. This gives you predictability: every Friday afternoon, your roadmap updates automatically.

Pro Tips

Rate Limits and Batching

Bhava AI and Mindpal both have rate limits. Bhava allows 100 requests per minute per API key; Mindpal allows 50 clustering operations per hour. If you're processing many requests, batch them. Set up n8n to collect requests for 30 minutes, then process them in one API call rather than triggering the workflow once per request. This also reduces your API cost.

Copy
// In n8n, add a "Collect" node
{
  "mode": "collect",
  "amount": "numbers",
  "numberValue": 10,
  "timeout": 1800  // 30 minutes
}

Error Handling and Retries

API calls fail sometimes. Network blips, rate limits, timeouts. Configure n8n to retry failed requests with exponential backoff. For Bhava and Mindpal, retry up to three times with a delay of 5, 10, then 20 seconds. If it still fails, log the error to a separate Slack channel so someone can investigate.

Copy
// Configure retry in n8n HTTP Request node
{
  "retry": {
    "maxTries": 3,
    "delayMs": 5000,
    "backoffMultiplier": 2
  }
}

Duplicate Detection Tuning

Bhava's duplicate detection works well but isn't perfect. Start with conservative settings (only flag something as "Definite Duplicate" if Bhava's confidence is above 0.85). Collect false positives for two weeks, then manually audit them and provide feedback to adjust Bhava's context instructions. Over time, it'll learn what "duplicate" means in your domain.

Cost Optimisation

Each tool charges per API call. Reduce unnecessary calls: don't classify every request from your own internal team, only external customers. Add a conditional that skips Bhava classification if the source is "internal_slack" or "internal_email". You'll cut costs by 30-40% without losing any roadmap value.

Versioning Your Roadmap

When Terrakotta generates a roadmap, store it with a timestamp and version number. This lets you compare how priorities have shifted over time. Add a "Previous Roadmap" column in your Google Sheet and use conditional formatting to highlight changes. This makes it obvious when a feature moved from Q2 to Q1 or dropped off entirely.

Cost Breakdown

If you're processing fewer than 100 requests per month, you can run this on the cheaper tiers of each tool and reduce your total to around £100–150 per month. If you're running this daily with thousands of requests, you'll move to higher tiers and spend £400–600 monthly. Either way, this is far cheaper than paying someone to manually process requests.