Customer feedback analysis and sentiment-driven action plan creation

Customer feedback is pouring in from every direction: support tickets, surveys, review sites, social media. Most teams read through it manually, spot a few themes, and maybe send out a vague action plan. The result? Insights get lost, patterns go unnoticed, and months pass before anyone realises customers have been asking for the same feature repeatedly....... For more on this, see Customer support ticket analysis and response automation. For more on this, see Customer feedback analysis to product roadmap alignment w....

The real problem isn't collecting feedback; it's turning feedback into decisions fast enough to matter. By the time a human finishes reading 500 comments, the sentiment data is already stale. You need a system that ingests feedback, identifies sentiment and themes automatically, then generates a prioritised action plan within hours, not weeks.

This is where combining Accio AI for feedback extraction, Terrakotta AI for sentiment analysis, and Twig for action plan synthesis creates something genuinely useful. Wire them together with an orchestration tool, and you move from "we gathered feedback" to "here's what we're doing about it" in a single automated flow.

The Automated Workflow

The workflow operates in four stages: collection, analysis, scoring, and action generation. Your orchestration tool triggers everything based on a schedule or a webhook event (e.g., a new survey completion or support ticket).

Stage 1: Trigger and Feedback Collection

Start with a schedule-based trigger or webhook. Most teams collect feedback from multiple sources: customer surveys, support tickets, review aggregators. The orchestration tool polls these sources or receives them via webhook.

For this example, assume feedback arrives via a webhook when a customer completes a survey. Here's how to set it up in n8n:

Copy
1. HTTP Request (Webhook)
   Method: POST
   Webhook URL: [your-n8n-webhook-url]
   Expected payload:
   {
     "feedback_id": "survey_12345",
     "customer_name": "Jane Smith",
     "feedback_text": "Your mobile app crashes when I try to export reports. I've reported this three times now.",
     "source": "survey",
     "date": "2024-01-15T10:30:00Z"
   }

If you're pulling feedback from multiple sources (support tickets from Zendesk, reviews from Trustpilot, survey responses from Typeform), create separate HTTP Request nodes for each source and merge the results. Most orchestration tools allow branching and joining data flows.

For Zapier, use a "Catch Hook" step to receive webhook data, then feed it into your workflow.

For Make (Integromat), the HTTP webhook module works similarly; you'll get a unique URL to configure in your source systems.

Stage 2: Feedback Extraction with Accio AI

Accio AI pulls structured data from unstructured feedback text. This is useful because raw customer feedback is messy: it's mixed with pleasantries, tangents, and unclear references. Accio extracts intent, topics, and key issues.

The Accio API endpoint is typically:

Copy
POST https://api.accio-ai.com/v1/extract
Authorization: Bearer YOUR_ACCIO_API_KEY
Content-Type: application/json

{
  "text": "Your mobile app crashes when I try to export reports. I've reported this three times now.",
  "extraction_type": "feedback",
  "fields": [
    "issue_category",
    "product_area",
    "severity_hint",
    "frequency"
  ]
}

Response structure:

Copy
{
  "extraction_id": "ext_98765",
  "extracted_data": {
    "issue_category": "bug",
    "product_area": "mobile_app",
    "severity_hint": "high",
    "frequency": "recurring"
  },
  "confidence_scores": {
    "issue_category": 0.94,
    "product_area": 0.89,
    "severity_hint": 0.87,
    "frequency": 0.91
  }
}

In your orchestration tool, create an HTTP Request node that calls this endpoint. Map the incoming feedback text to the text parameter. Store the response for the next stage.

Stage 3: Sentiment Analysis with Terrakotta AI

Once you've extracted what the feedback is about, you need to understand how the customer feels. Terrakotta AI provides sentiment scoring, emotion detection, and urgency flagging.

The Terrakotta API endpoint:

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

{
  "text": "Your mobile app crashes when I try to export reports. I've reported this three times now.",
  "include_emotions": true,
  "urgency_detection": true
}

Response:

Copy
{
  "sentiment_id": "sent_54321",
  "overall_sentiment": "negative",
  "sentiment_score": -0.78,
  "emotions": [
    {
      "emotion": "frustration",
      "intensity": 0.85
    },
    {
      "emotion": "disappointment",
      "intensity": 0.72
    }
  ],
  "urgency_flag": true,
  "urgency_score": 0.81
}

In your workflow, add another HTTP Request node for Terrakotta. Pass the same feedback text. The sentiment score ranges from -1 (very negative) to +1 (very positive). The urgency flag is particularly useful for prioritisation.

Stage 4: Action Plan Generation with Twig

Now you have structured data (what the issue is) and sentiment data (how upset the customer is). Twig synthesises this into actionable recommendations.

The Twig API endpoint:

Copy
POST https://api.twig-ai.com/v1/action-plan
Authorization: Bearer YOUR_TWIG_API_KEY
Content-Type: application/json

{
  "feedback_summary": {
    "issue_category": "bug",
    "product_area": "mobile_app",
    "specific_issue": "app crashes during report export",
    "frequency": "recurring"
  },
  "sentiment": {
    "overall_sentiment": "negative",
    "sentiment_score": -0.78,
    "urgency_score": 0.81
  },
  "context": {
    "customer_segment": "premium",
    "previous_reports": 3
  }
}

Response:

Copy
{
  "action_plan_id": "ap_11111",
  "recommended_actions": [
    {
      "action_id": "act_001",
      "action": "Fix crash in report export function",
      "priority": "critical",
      "rationale": "Recurring issue affecting core feature; high customer frustration",
      "estimated_effort": "2 days",
      "owner_team": "mobile_engineering"
    },
    {
      "action_id": "act_002",
      "action": "Reach out to customer with timeline",
      "priority": "high",
      "rationale": "Multiple reports from same customer; demonstrates responsiveness",
      "estimated_effort": "1 hour",
      "owner_team": "customer_success"
    },
    {
      "action_id": "act_003",
      "action": "Add logging to report export flow",
      "priority": "high",
      "rationale": "Improve debugging for similar issues",
      "estimated_effort": "1 day",
      "owner_team": "mobile_engineering"
    }
  ],
  "summary": "Critical bug with strong customer impact. Recommend immediate fix and proactive outreach."
}

Connecting It All in Your Orchestration Tool

Here's how the flow looks in n8n (similar logic applies to Zapier and Make):

1. HTTP Request (Webhook): Receive feedback
2. HTTP Request (Accio): Extract structured data
3. HTTP Request (Terrakotta): Analyse sentiment
4. HTTP Request (Twig): Generate action plan
5. Save to Database or Send to Slack (or both)

Each step depends on the previous one. Set error handling to log failures without stopping the entire workflow.

In n8n, your configuration would look something like this pseudocode:

Copy
Node 1: Webhook Trigger
  - Wait for POST request
  - Extract: feedback_text, customer_name, source

Node 2: Accio Extract
  - URL: https://api.accio-ai.com/v1/extract
  - Headers: Authorization: Bearer {{ $env.ACCIO_KEY }}
  - Body: { "text": {{ $node.Webhook.json.feedback_text }}, "extraction_type": "feedback" }
  - Store as: extracted_data

Node 3: Terrakotta Sentiment
  - URL: https://api.terrakotta-ai.com/v1/sentiment
  - Headers: Authorization: Bearer {{ $env.TERRAKOTTA_KEY }}
  - Body: { "text": {{ $node.Webhook.json.feedback_text }} }
  - Store as: sentiment_data

Node 4: Twig Action Plan
  - URL: https://api.twig-ai.com/v1/action-plan
  - Headers: Authorization: Bearer {{ $env.TWIG_KEY }}
  - Body: {
      "feedback_summary": {{ $node["Accio Extract"].json.extracted_data }},
      "sentiment": {{ $node["Terrakotta Sentiment"].json }},
      "context": { "customer_segment": {{ $node.Webhook.json.customer_segment }} }
    }
  - Store as: action_plan

Node 5: Database Insert
  - Create record with: feedback_id, original_text, extracted_data, sentiment, action_plan, timestamp

Node 6: Slack Notification
  - Send action_plan summary to #customer-insights channel

In Zapier, you'd structure this as:

Copy
Trigger: Webhook (Catch Hook)
  |
Action 1: Accio AI via API (HTTP)
  |
Action 2: Terrakotta AI via API (HTTP)
  |
Action 3: Twig AI via API (HTTP)
  |
Action 4: Google Sheets (or Airtable) append row
  |
Action 5: Slack send message

For Make (Integromat), use the HTTP module for each API call, connected sequentially, with data mapping between each step.

Data Flow Example

Let's trace one piece of feedback through the system:

1. Customer submits survey: "App keeps crashing when exporting reports. I've told you three times!"
2. Webhook fires, orchestration tool receives: { feedback_text: "...", customer_name: "Jane Smith", source: "survey" }
3. Accio extracts: { issue_category: "bug", product_area: "mobile_app", frequency: "recurring" }
4. Terrakotta scores: { sentiment: -0.78, urgency: 0.81, emotions: [frustration, disappointment] }
5. Twig generates: { actions: [{action: "Fix crash", priority: "critical", owner: "mobile_engineering"}, ...] }
6. Entire result stored in database, Slack message sent to #customer-insights with action summary

From the moment the webhook fires to the Slack notification, the entire process takes 10-30 seconds, depending on API response times.

The Manual Alternative

If you prefer more control over each step, or need custom business logic, you can run the same tools separately.

Collect feedback in a spreadsheet or Airtable base. Once weekly, run Accio on a batch of new feedback entries. Review the extracted data manually if you have concerns. Then run Terrakotta on the same batch. Finally, use the combined output to feed into Twig.

This approach gives you checkpoints to validate results before the next stage. The trade-off is obvious: it takes much longer and requires human attention at each step.

You might also process feedback in smaller batches instead of individually, which reduces API calls but increases latency. For example, collect feedback for 24 hours, then run the full pipeline once daily rather than on every single submission.

Pro Tips

Error Handling and Retries

APIs fail. Network timeouts happen. Rate limits exist. Your orchestration tool should retry failed requests, but configure it intelligently:

• Use exponential backoff: first retry after 2 seconds, then 4, then 8.

• Set a maximum retry count (e.g., 3 retries) to avoid infinite loops.

• Log failures with full context so you can debug later.

• Consider a separate error handling flow that alerts you when critical stages fail.

In n8n, use the "Error Trigger" node to catch failures and route them to a Slack notification or database log.

Rate Limits and Cost Control

Each API has rate limits. Accio, Terrakotta, and Twig typically allow 100-1000 requests per minute depending on your plan.

• Monitor actual usage in your orchestration tool. Log API response headers that indicate remaining quota.

• If feedback volume spikes, you might hit limits. Either batch feedback in larger chunks or upgrade your plan temporarily.

• Some APIs charge per request. Twig might cost 0.02 per action plan generated. At 500 pieces of feedback per month, that's roughly £5-10.

Deduplication

Customers sometimes submit identical or near-identical feedback multiple times. Processing duplicates wastes API calls and skews your sentiment analysis.

Add a deduplication step before Accio. Use a simple hash of the feedback text, or implement fuzzy matching (string similarity above 85% = probable duplicate). Store processed feedback IDs in a database and skip any you've already handled in the past 7 days.

Grouping Feedback by Theme

Instead of generating one action plan per piece of feedback, batch similar feedback together and generate one action plan per theme.

After Terrakotta scores sentiment, add a grouping step that clusters feedback by extracted issue_category and product_area. Then pass the entire cluster to Twig. This produces higher-quality action plans because Twig sees the full picture (e.g., "10 customers reported the same crash, urgency scores average 0.79").

Storing and Querying Results

Use a database that supports JSON storage and full-text search: PostgreSQL with jsonb columns, MongoDB, or even Airtable.

Store the complete result at each stage (raw feedback, extracted data, sentiment, action plan). This lets you run historical analyses without re-processing everything. You can query: "Show me all critical bugs from Q4" or "Which product areas have the most negative sentiment?"

Create views or dashboards in your database tool (e.g., PostgreSQL + Grafana, or Airtable + built-in views) that surface key metrics: sentiment distribution, most common issues, actions by team.

Cost Breakdown

Keep in mind that costs scale with feedback volume. A startup processing 100 pieces of feedback monthly costs far less than an enterprise processing 50,000. Many vendors offer bulk discounts or custom pricing for higher volumes.

The orchestration tool cost is usually negligible compared to the AI APIs themselves. Choose based on ease of use and features you need (error handling, conditional logic, data transformation).