Customer feedback analysis and product roadmap alignment

Product managers face a constant challenge: customer feedback arrives through dozens of channels, sits in inboxes, and rarely makes it into roadmap decisions in any systematic way. You get feature requests via email, bug reports in support tickets, feedback from sales calls, and comments scattered across review sites. By the time you've manually sorted through all of it, patterns have become noise and priorities have blurred. For more on this, see Software feature request processing and roadmap generation.

The real problem is the handoff. Someone reads feedback, someone else summarises it, another person cross-references it with existing roadmap items, and then it sits in a spreadsheet waiting for the next planning cycle. Each manual step introduces delay and inconsistency. What if every piece of customer feedback could be automatically analysed, categorised, and compared against your product roadmap within minutes of arrival? What if you had a single, constantly updated view of what customers actually want versus what you're actually building?

This workflow uses three focused AI tools connected through an orchestration platform to create exactly that: a system where customer feedback is automatically extracted, analysed for themes and sentiment, and mapped to your existing product roadmap without any human intervention between capture and insight.

The Automated Workflow

We'll build this workflow using n8n as the orchestration backbone, though Zapier and Make will work with minor adjustments. The three tools each handle a specific task: bhava-ai extracts structured data from raw feedback, Chat with PDF by Copilotus compares feedback against your roadmap document, and Terrakotta AI identifies strategic themes.

Tool Selection and Architecture

bhava-ai is your initial processing engine. It's designed to take unstructured customer feedback (emails, chat messages, support tickets) and extract structured data: what the customer wants, what problem they're solving, urgency level, and affected user segment. This converts messy natural language into machine-readable facts.

Chat with PDF by Copilotus does something most AI tools can't easily do: it lets you upload your product roadmap as a PDF and then query it. This becomes your source of truth for what you're already planning to build. The AI can quickly tell you whether incoming feedback aligns with existing initiatives or represents something new.

Terrakotta AI sits at the end of the chain. It's built for pattern recognition across large feedback datasets. It looks at multiple analysed feedback items and identifies recurring themes, priority areas, and gaps between customer expectations and your roadmap.

The data flows like this: raw feedback enters n8n through a webhook or email integration, gets sent to bhava-ai for initial structuring, that structured data is compared against your roadmap PDF via Chat with PDF, and the results all feed into Terrakotta AI for thematic analysis. Final insights get written to a shared Google Sheet that your product team reviews daily.

Setting Up the n8n Workflow

Start with a new workflow in n8n. Your trigger will depend on where feedback originates. For this example, we'll assume you're collecting feedback through a simple web form, but the same pattern works if you're pulling from support tickets, emails, or Slack channels.

Create a webhook trigger node:

Copy
POST /webhook/customer-feedback
{
  "customer_name": "string",
  "feedback_text": "string",
  "feedback_source": "string",
  "timestamp": "ISO8601"
}

This webhook receives POST requests whenever someone submits feedback through your form. n8n generates a unique URL you'll point your form submission to.

Node 1: bhava-ai Extraction

From the webhook, wire in an HTTP Request node configured for bhava-ai:

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

Body:
{
  "text": "{{ $json.feedback_text }}",
  "categories": ["feature_request", "bug_report", "user_segment", "urgency"],
  "extract_sentiment": true
}

bhava-ai returns structured JSON that looks like this:

Copy{
  "extracted_data": {
    "primary_need": "Bulk export functionality for reports",
    "category": "feature_request",
    "user_segment": "Enterprise customers",
    "urgency": "high",
    "sentiment": "frustrated",
    "pain_points": ["Manual report building is time-consuming", "No API for automation"]
  },
  "confidence_score": 0.94
}

Store this output in a variable so you can reference it later. In n8n, you do this by clicking the output and setting it to a variable name, or you can use the Set node to explicitly create variables:

Copy
Set node:
  name = bhava_output
  value = {{ $json.extracted_data }}

Node 2:

Chat with PDF by Copilotus Comparison

Now take that structured feedback and compare it against your product roadmap. First, you need to upload your roadmap PDF to Copilotus. Do this manually once through their dashboard and note the document ID they provide.

Wire in another HTTP Request node for Copilotus:

Copy
POST https://api.copilotus.ai/chat
Headers:
  Authorization: Bearer YOUR_COPILOTUS_API_KEY
  Content-Type: application/json

Body:
{
  "document_id": "roadmap-pdf-id-12345",
  "query": "Is there already a planned feature for: {{ $json.bhava_output.primary_need }}? If yes, what quarter is it scheduled for?",
  "include_sources": true
}

Copilotus will scan your roadmap PDF and respond with something like:

Copy{
  "answer": "Yes, bulk export functionality is planned for Q2 2025 as part of the Enterprise Features initiative. It's currently in the design phase.",
  "confidence": 0.89,
  "referenced_sections": ["Q2 2025 Roadmap", "Enterprise Features"]
}

Store this response as well:

Copy
Set node:
  name = roadmap_match
  value = {{ $json.answer }}

Node 3:

Terrakotta AI Thematic Analysis

Rather than sending individual feedback to Terrakotta, we want to batch process several feedback items together so thematic patterns emerge. Set up a scheduled trigger that runs every 4 hours and pulls all feedback collected since the last run.

First, store feedback in a database. Add a node that writes the bhava-ai output to a Google Sheet or PostgreSQL database. For Google Sheets:

Copy
Add a Google Sheets node:
  Action: Append or update
  Sheet: Customer Feedback Analysis
  
Columns:
  timestamp | customer_name | primary_need | category | urgency | sentiment | roadmap_match | extracted_by
```............ 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 sentiment-driven action pl...](/blog/customer-feedback-analysis-and-sentiment-driven-action-plan-creation).

Then create a second workflow with a scheduled trigger (every 4 hours), and use a Read from Database or Read from Google Sheets node to pull all unprocessed feedback from the last 4 hours.

Pass the batch to Terrakotta AI:

POST https://api.terrakotta-ai.com/v1/analyse-themes Headers: Authorization: Bearer YOUR_TERRAKOTTA_API_KEY Content-Type: application/json

Body: { "feedback_items": [ { "id": "feedback-001", "text": "{{ $json.primary_need }}", "category": "{{ $json.category }}", "urgency": "{{ $json.urgency }}" }, // ... more feedback items ], "min_theme_frequency": 3, "include_sentiment_analysis": true }

Copy
Terrakotta returns something like:

```json
{
  "themes": [
    {
      "theme": "Export and integration capabilities",
      "frequency": 8,
      "affected_segments": ["Enterprise", "Mid-market"],
      "sentiment_distribution": {
        "frustrated": 0.62,
        "neutral": 0.25,
        "satisfied": 0.13
      },
      "roadmap_alignment": "Partial (Q2 2025)"
    },
    {
      "theme": "Mobile app improvements",
      "frequency": 5,
      "affected_segments": ["SMB", "Individual"],
      "sentiment_distribution": {
        "frustrated": 0.40,
        "neutral": 0.40,
        "satisfied": 0.20
      },
      "roadmap_alignment": "None identified"
    }
  ]
}

Final Output:

Google Sheet Update

Wire the Terrakotta results to a Google Sheet that your product team checks daily. This sheet acts as your single source of truth for customer feedback priorities:

Copy
Add a Google Sheets node:
  Action: Append
  Sheet: Weekly Feedback Themes
  
Columns:
  week | theme | frequency | affected_segments | sentiment | roadmap_status | action_needed
  
Values:
  week = {{ new Date().toISOString() }}
  theme = {{ $json.themes[0].theme }}
  frequency = {{ $json.themes[0].frequency }}
  affected_segments = {{ $json.themes[0].affected_segments.join(", ") }}
  sentiment = {{ $json.themes[0].sentiment_distribution }}
  roadmap_status = {{ $json.themes[0].roadmap_alignment }}
  action_needed = {{ $json.themes[0].roadmap_alignment === "None identified" ? "YES" : "NO" }}

Optionally, add a Slack notification node at the end so your PM team gets pinged whenever a high-priority theme emerges:

Copy
Add a Slack node:
  Channel: #product-feedback
  Message:
    New theme identified: {{ $json.themes[0].theme }}
    Frequency: {{ $json.themes[0].frequency }} mentions
    Affected: {{ $json.themes[0].affected_segments.join(", ") }}
    Roadmap alignment: {{ $json.themes[0].roadmap_alignment }}

Enable this notification only if roadmap_alignment is "None identified" to avoid noise.

Error Handling and Retries

All three APIs can occasionally timeout or hit rate limits. Add error handling to each HTTP Request node:

Copy
HTTP Request node settings:
  Retry: On Network Error
  Max Retries: 3
  Retry Delay: 5 seconds

Add error handler for rate limits:
  If response status = 429
  Wait 60 seconds
  Then retry the request

In n8n, you do this by adding an Error Trigger node after each HTTP Request and configuring a Wait node before retry.

The Manual Alternative

If you want more control over how feedback is processed or you'd rather not fully automate this, you can use a hybrid approach:

Run the workflow but instead of auto-posting results to a shared sheet, send them to yourself or your PM for review first. Add an Email node at the end that sends you the Terrakotta analysis with a button to "Approve and Post to Roadmap" or "Need More Review". This gives you a human checkpoint.

Alternatively, skip bhava-ai and do the initial feedback extraction manually in your support system or CRM. You still gain the efficiency of automatic roadmap comparison and thematic analysis, but you avoid potential misclassification of urgent feedback. This is sensible if you handle fewer than 20 customer feedback items per week.

You can also run Terrakotta AI manually on a weekly basis rather than every 4 hours. Collect feedback in a spreadsheet throughout the week, then batch process it on Friday afternoon. This costs less and still gives you weekly insight cycles.

Pro Tips

1. Validate bhava-ai extraction accuracy early

Before full automation, run the first 20 feedback items through bhava-ai and manually check whether the primary_need and category are correct. bhava-ai typically has 90%+ accuracy, but edge cases exist. Once you're confident, expand to full automation. If accuracy drops below 85%, you've likely got too much domain-specific language in your feedback; consider adding custom dictionaries to bhava-ai's API call.

2. Keep your roadmap PDF current

The roadmap comparison only works if your PDF is always current. Set a reminder to update your Copilotus document every two weeks, at minimum. Every time you move a feature between quarters or change status, regenerate the PDF and re-upload it. Consider using a tool like Gitbook or Notion to maintain your roadmap, export as PDF, and automate the Copilotus upload via a second n8n workflow.

3. Watch for API rate limits

bhava-ai allows 100 requests per minute on standard plans. If you expect more than 100 feedback submissions per minute (unlikely but possible at scale), you'll need a higher tier. Set up a queue in n8n that batches requests and spreads them across 60 seconds. Terrakotta AI's theme analysis can process larger batches; send 50 items at once rather than one at a time to reduce API calls.

4. Cost optimisation: batch processing windows

Don't run analysis immediately on every single feedback item. Instead, collect feedback in your database or sheet without analysis, then run the full bhava-ai + Copilotus + Terrakotta pipeline once every 4 hours during business hours. This reduces API costs by 75% while still giving you fresh insights four times daily. For most product teams, that's more than sufficient.

5. Track feedback that changes your roadmap

Once you identify a high-frequency theme that isn't on your roadmap, you'll want to remember which customers mentioned it so you can loop them back when you ship the feature. Add a step after Terrakotta that queries your feedback database for all items matching the identified theme and creates a Google Contact list or Slack channel for those customers. When you launch the feature, you've got a ready-made group to notify.

Cost Breakdown

For comparison, hiring a part-time analyst to do this manually costs £800–1,200 per month in salary. This workflow pays for itself instantly.