FeedForward — Devpost Project Story
Inspiration
Every product team we've been part of has the same recurring problem: there's too much customer feedback and never enough time to read it properly. G2 reviews pile up. Support tickets accumulate. NPS surveys go into a spreadsheet that nobody opens after the first week. The synthesis step — turning all of that noise into a clear, prioritized strategic signal — gets done manually, inconsistently, and usually by whoever has 4 spare hours before the sprint planning meeting.
We wanted to ask: what if that process took 30 seconds instead?
The insight that drove us was simple. The hard part of working with customer feedback isn't collection — companies collect plenty. It's reasoning: Which themes matter most? Which pain points carry the highest business risk? What should we build now versus later, and why? That's exactly the kind of structured reasoning Claude excels at. So we built FeedForward to let Claude do the heavy lifting, and get out of the way.
What it does
FeedForward takes raw customer feedback — as a CSV upload, a drag-and-drop file, or plain pasted text — and transforms it into a complete, actionable product strategy dashboard in under 30 seconds.
The output has four components:
- Themes — Claude clusters the feedback into 5–8 distinct, meaningful themes with sentiment labels, frequency counts, and representative quotes pulled directly from the source reviews.
- Pain Points — 8–12 specific issues ranked by severity (
critical → high → medium → low) and business impact, with the affected customer segment identified for each. - Now / Next / Later Roadmap — A prioritized product roadmap where every item carries a rationale that cites actual evidence from the feedback (e.g., "23 Enterprise customers reported..."), plus an effort estimate (S/M/L) and impact rating.
- Executive Summary — A markdown brief structured for leadership: overall insight anchored to a key statistic, top pain points, business impact framing, and three concrete product refinements in priority order. Copy-paste ready for a board update or a Slack message to your VP.
What takes a PM (4^+) hours now takes (\approx 30) seconds.
How we built it
The core of FeedForward is a two-call Claude pipeline via OpenRouter, running inside a Next.js App Router application.
Call 1 — /api/analyze
We format each review into a structured block with optional metadata (source, customer segment, plan tier, rating), then send the full batch to Claude in an XML-tagged prompt. The model is instructed to return strict JSON — no markdown, no explanation — with two arrays: themes and painPoints. Temperature is set to 0.3 to keep the output consistent and grounded.
[R001] Source: G2 | Segment: Enterprise | Plan: Pro
"The onboarding took our team a full week. No guided setup flow exists."
Claude does real clustering here, not keyword matching. It identifies latent patterns across reviews, segments them by semantic similarity, and ranks pain points by inferred business consequence.
Call 2 — /api/generate
The themes and pain points from Call 1 are passed — still as structured JSON — into a second prompt that asks Claude to reason as a senior PM. This call produces the Now/Next/Later roadmap (with evidence-cited rationales) and the executive summary in a precisely specified markdown format.
The separation of concerns between the two calls was deliberate: Call 1 is analytical (what's happening?), Call 2 is strategic (what should we do?). Chaining them lets us keep each prompt tightly scoped and the outputs reliably structured.
JSON safety layer
LLMs occasionally produce malformed JSON — unterminated strings, stray control characters, markdown fences around the output. We wrote a safeJsonParse function that handles all of these cases: stripping markdown fences, escaping literal newlines and tabs inside string values using a character-by-character state machine, and applying a targeted repair heuristic for the specific "unterminated string at end of input" failure mode we observed in production testing.
Frontend
The UI is a single-page React app with two routes (/ for input, /results for the dashboard). State is passed between routes via sessionStorage — no database, no auth, no infrastructure. The results page uses a four-tab dashboard (Roadmap, Pain Points, Themes, Executive Summary) built on shadcn/ui with Tailwind CSS v4. CSV parsing is handled client-side by PapaParse, and the executive summary renders via react-markdown with @tailwindcss/typography.
Challenges we ran into
Prompt engineering for strict JSON output. Getting Claude to return only a valid JSON object — no preamble, no explanation, no trailing commentary — required careful prompt construction. We used explicit negative instructions ("No markdown, no explanation — only the JSON object") and validated heavily on the output side with our safety parser.
Handling malformed JSON from the model. Even with strict instructions, Claude occasionally produced outputs with literal newline characters inside JSON string values, which breaks JSON.parse. We built a character-by-character string parser to escape control characters only within string boundaries — a subtle but important distinction, since you can't just globally replace \n with \\n without corrupting the JSON structure itself.
Making the executive summary consistently structured. The format we wanted — exactly 4 bullets in the executive section, exactly 3 product refinements, statistics woven into prose rather than listed separately — required a very detailed prompt spec with explicit rules and anti-patterns ("avoid: 'users feel like'", "avoid: 'there are many different issues'"). Getting this right across a range of input sizes and topic types took multiple iterations.
Balancing specificity and generality. The roadmap items needed to be evidence-specific (citing actual data) without being overfit to a particular feedback dataset. We solved this by grounding the second-call prompt entirely in the structured output from Call 1, forcing every recommendation to trace back to real theme and pain point data.
Accomplishments that we're proud of
- A genuinely usable product that produces high-quality, non-generic output on real feedback data
- A two-stage AI pipeline where each call has a clearly scoped responsibility and passes structured state
- A JSON safety layer robust enough to handle the full range of LLM output edge cases we encountered
- Zero infrastructure: no database, no login, no backend beyond two Next.js API routes — fully deployable in one Vercel command
- An executive summary format precise enough to drop directly into a real team meeting without editing
What we learned
Prompt structure matters more than prompt length. The biggest quality improvements came not from adding more instructions, but from organizing them better — separating rules by output section, using explicit anti-pattern lists, and specifying the exact format with worked examples.
Two smaller, focused AI calls outperform one large call. Splitting analysis from strategy generation produced cleaner outputs and made debugging far easier. When the roadmap was wrong, we knew immediately whether the problem was in the clustering step or the prioritization step.
Defensive JSON parsing is non-negotiable for production LLM apps. JSON.parse will fail in production. The question is just when and how. Writing a real parser — not just a try/catch with a regex fallback — was the right investment.
The synthesis gap is real. When we ran FeedForward on actual B2B SaaS feedback data during testing, the output was immediately useful and noticeably sharper than what a human analyst would produce under time pressure. The model doesn't get fatigued, doesn't anchor on the first review it reads, and doesn't unconsciously weight feedback from the loudest customer.
What's next for FeedForward
- Direct integrations — Pull feedback automatically from Intercom, Zendesk, G2, and Typeform without needing a CSV export
- Trend analysis across time — Compare roadmaps from multiple time periods to surface emerging vs. declining pain points
- Segment filtering — Let PMs drill into a specific customer tier (e.g., Enterprise only) and generate a targeted roadmap for that cohort
- Shareable report links — Persistent, shareable URLs for analysis results so the whole team can view without re-running
- Slack integration — Post the executive summary directly to a Slack channel on a scheduled cadence (e.g., after every sprint)
- Confidence scoring — Surface how well-supported each roadmap item is by the underlying evidence, giving PMs a signal for where more feedback collection is needed