u/rey19Sin

Okay so I've been working on this thing called Feedzap and I'm genuinely shocked at how well the core feature works.

The problem: Most teams have scattered customer feedback everywhere. Email, Slack, support tickets, calls. But they're also missing what's actually happening in the product — where users are frustrated, where they're clicking in confusion, where they're just giving up.

What Feedzap does differently: We track behavioral signals (rage clicks, dead clicks, scroll frustration) in your product. At the same time, customers submit feedback through a widget. Instead of these being separate data streams, we cluster and pattern-match them together.

So you see: "This button triggered 347 rage clicks" + "Customers mentioned in 12 different support tickets that this button is broken" = one clear pattern: "Search button broken on mobile, blocking 45 users."

That's not just data. That's behavioral confirmation + voice of customer combined into one actionable pattern.

That's when Execute comes in. We have this thing called "Execute" that generates code patches automatically based on these clustered patterns.

Real example:

• Button gets 300+ rage clicks (behavioral signal)
• 7 customers report same issue through the feedback widget
• Feedzap clusters both signals into one pattern
• Pattern shows: "Search broken on mobile, affecting 45 users across both signals"
• Execute reads the pattern + generates a Next.js/React/Tailwind patch
• Developer reviews it (30 seconds)
• PR opens
• Fix ships same day

Instead of 3 hours debugging, you already know from behavioral + feedback patterns what's broken.

The insane part: It actually works. 60-70% of patches are production-ready. The other 30% needs tweaks. So you're cutting bug-fix time from 3 hours to 30-60 minutes.

Combine that with pattern recognition:

You don't just see isolated data points. You see clustered patterns where behavioral signals + customer feedback converge. Multiple sources confirming the same problem.

So you see:

• 45 users rage clicked a button (behavioral)
• 12 customers mentioned it in feedback (voice of customer)
• Both point to same issue
• Execute generates the fix
• You ship it
• Problem solved

The real moat: We pair behavioral tracking with pattern recognition and feedback clustering from the widget. Behavioral data shows where users are frustrated. Feedback widget captures why. Pattern clustering connects the dots between them. Then code generation fixes it. It's a full loop.

But now I'm trying to get people to actually use it and... nothing.

But if you're a founder or dev reading this - would you use something that:

1. Tracks behavioral signals in your product (where users are frustrated)
2. Collects feedback through a widget (why they're frustrated)
3. Clusters and pattern-matches both signals together
4. Auto-generates code patches for high-impact patterns
5. Saves you 6+ hours per week

Or does that sound too sci-fi?

We’ve got around ~50 paying customers now and feedback comes from everywhere. emails, slack, support chats, random calls, twitter DMs. everyone asking for diff things.

And i genuinely cant tell if something is:

• one annoying customer problem
• something a few ppl actually want
• or a “holy shit this is the real issue” type thing

so most of the time i just end up building whatever i heard most recently 😭 or whatever sounded smart in the moment. sometimes just whoever complained the loudest tbh.

then we ship it and like… nobody uses it.

Real example:
spent almost 2 weeks building a feature last month. was convinced ppl needed it. shipped it. literally 12% adoption.

Meanwhile there’s this OTHER issue people keep mentioning over and over in diff places but i didnt even realize it was the same pattern until later bc the wording was diff every time.

Feels like im building blind honestly.

Like how do you guys figure out:

• whats a real feature request vs random noise
• which customers feedback matters more
• whats actually broken vs mildly inconvenient

Do you all have some system for this? spreadsheets? tools? rituals? lol

or is founder life just shipping random stuff and praying something sticks

Okay so I've been working on this thing called Feedzap.live and I'm genuinely shocked at how well the core feature works.

The problem: Customer feedback usually goes like this:

1. Customer: "This button is broken"
2. You: "Thanks for reporting, we'll fix it"
3. Developer: spends 3 hours debugging, finding the issue, writing the patch
4. Customer: waits 3 days for the fix

That's the normal workflow. It sucks.

What Feedzap does differently: Customer takes a screenshot of what's broken, adds context, sends it through Feedzap. It lands in our inbox. From there, your team can push it to Linear, Jira, Slack - wherever your workflow lives.

But here's where it gets good — when multiple customers report the same bug through different channels (email, support, chat), Feedzap shows you the pattern. You see that 7 customers reported the same issue. Now it's not "one person's bug," it's "this is actively breaking things for 7 people."

That's when Execute comes in. We have this thing called "Execute" that literally generates a code patch automatically.

Like... the AI reads what's broken and generates the fix.

Real example:

• Customer: "Search button doesn't work on mobile"
• Screenshot + context sent through Feedzap
• More customers report the same thing through different channels
• You see the pattern (multiple reports = this is real)
• Execute generates a Next.js/React/Tailwind patch automatically
• Developer reviews it and only then gives a green flag.
• PR opens to their repo
• Fix ships same day

Instead of 3 hours of dev time, it's 30 minutes of review + maybe adjustments.

The insane part: It actually works. Not like "kinda works," but the patches are legit. I'd say 60-70% of the time the AI-generated patch is good enough to ship as-is. The other 30% needs minor tweaks.

So you're cutting bug-fix time from 3 hours to 30-60 minutes.

Combine that with feedback organization:

Feedzap also organizes all your scattered customer feedback (emails, Slack, support tickets) and shows you what customers are asking for most.

So you see:

• 23 customers mentioned a specific bug
• Execute generates the fix
• You ship it
• 23 customers are happy

It's not just about shipping faster. It's about shipping what customers are actually screaming for, instantly.

But now I'm trying to get people to actually use it and... nothing.

But if you're a founder or dev reading this — would you use something that:

1. Organizes your scattered customer feedback
2. Shows you what customers are asking for most
3. Automatically generates code patches for reported bugs
4. Saves you 6+ hours per week

Or does that sound too sci-fi?

Okay so I've been working on this thing called Feedzap.live and I'm genuinely shocked at how well the core feature works.

The problem: Customer feedback usually goes like this:

1. Customer: "This button is broken"
2. You: "Thanks for reporting, we'll fix it"
3. Developer: spends 3 hours debugging, finding the issue, writing the patch
4. Customer: waits 3 days for the fix

That's the normal workflow. It sucks.

What Feedzap does differently: Customer takes a screenshot of what's broken, adds context, sends it through Feedzap. It lands in our inbox. From there, your team can push it to Linear, Jira, Slack - wherever your workflow lives.

But here's where it gets good — when multiple customers report the same bug through different channels (email, support, chat), Feedzap shows you the pattern. You see that 7 customers reported the same issue. Now it's not "one person's bug," it's "this is actively breaking things for 7 people."

That's when Execute comes in. We have this thing called "Execute" that literally generates a code patch automatically.

Like... the AI reads what's broken and generates the fix.

Real example:

• Customer: "Search button doesn't work on mobile"
• Screenshot + context sent through Feedzap
• More customers report the same thing through different channels
• You see the pattern (multiple reports = this is real)
• Execute generates a Next.js/React/Tailwind patch automatically
• Developer reviews it and only then gives a green flag.
• PR opens to their repo
• Fix ships same day

Instead of 3 hours of dev time, it's 30 minutes of review + maybe adjustments.

The insane part: It actually works. Not like "kinda works," but the patches are legit. I'd say 60-70% of the time the AI-generated patch is good enough to ship as-is. The other 30% needs minor tweaks.

So you're cutting bug-fix time from 3 hours to 30-60 minutes.

Combine that with feedback organization:

Feedzap also organizes all your scattered customer feedback (emails, Slack, support tickets) and shows you what customers are asking for most.

So you see:

• 23 customers mentioned a specific bug
• Execute generates the fix
• You ship it
• 23 customers are happy

It's not just about shipping faster. It's about shipping what customers are actually screaming for, instantly.

But now I'm trying to get people to actually use it and... nothing.

But if you're a founder or dev reading this — would you use something that:

1. Organizes your scattered customer feedback
2. Shows you what customers are asking for most
3. Automatically generates code patches for reported bugs
4. Saves you 6+ hours per week

Or does that sound too sci-fi?

Okay so I've been working on this thing called Feedzap and I'm genuinely shocked at how well the core feature works.

The problem: Customer feedback usually goes like this:

1. Customer: "This button is broken"
2. You: "Thanks for reporting, we'll fix it"
3. Developer: spends 3 hours debugging, finding the issue, writing the patch
4. Customer: waits 3 days for the fix

That's the normal workflow. It sucks.

What Feedzap does differently: Customer takes a screenshot of what's broken, adds context, sends it through Feedzap. We have this thing called "Execute" that literally generates a code patch automatically.

Like... the AI reads what's broken and generates the fix.

Real example:

• Customer: "Search button doesn't work on mobile"
• Screenshot + context sent
• Execute generates a Next.js/React/Tailwind patch automatically
• Developer previews it (takes 30 seconds)
• PR opens to their repo
• Fix ships same day

Instead of 3 hours of dev time, it's 30 minutes of review + maybe adjustments.

The insane part: It actually works. Not like "kinda works," but the patches are legit. I'd say 60-70% of the time the AI-generated patch is good enough to ship as-is. The other 30% needs minor tweaks.

So you're cutting bug-fix time from 3 hours to 30-60 minutes.

Combine that with feedback organization:

Feedzap also organizes all your scattered customer feedback (emails, Slack, support tickets) and shows you what customers are asking for most.

So you see:

• 23 customers mentioned a specific bug
• Execute generates the fix
• You ship it
• 23 customers are happy

It's not just about shipping faster. It's about shipping what customers are actually screaming for, instantly.

But now I'm trying to get people to actually use it and... nothing.

So either:

• People think their tools already do this (they don't)
• They're scared of AI-generated code (fair)
• They don't know it exists
• I'm explaining it wrong
• The free tier has some limitation I'm missing

I genuinely don't know.

But if you're a founder or dev reading this - would you use something that:

1. Organizes your scattered customer feedback
2. Shows you what customers are asking for most
3. Automatically generates code patches for reported bugs
4. Saves you 6+ hours per week

Or does that sound too sci-fi?

Okay so I've been working on this thing called Feedzap and I'm genuinely shocked at how well the core feature works.

The problem: Customer feedback usually goes like this:

1. Customer: "This button is broken"
2. You: "Thanks for reporting, we'll fix it"
3. Developer: spends 3 hours debugging, finding the issue, writing the patch
4. Customer: waits 3 days for the fix

That's the normal workflow. It sucks.

What Feedzap does differently: Customer takes a screenshot of what's broken, adds context, sends it through Feedzap. We have this thing called "Execute" that literally generates a code patch automatically.

Like... the AI reads what's broken and generates the fix.

Real example:

• Customer: "Search button doesn't work on mobile"
• Screenshot + context sent
• Execute generates a Next.js/React/Tailwind patch automatically
• Developer previews it (takes 30 seconds)
• PR opens to their repo
• Fix ships same day

Instead of 3 hours of dev time, it's 30 minutes of review + maybe adjustments.

The insane part: It actually works. Not like "kinda works," but the patches are legit. I'd say 60-70% of the time the AI-generated patch is good enough to ship as-is. The other 30% needs minor tweaks.

So you're cutting bug-fix time from 3 hours to 30-60 minutes.

Combine that with feedback organization:

Feedzap also organizes all your scattered customer feedback (emails, Slack, support tickets) and shows you what customers are asking for most.

So you see:

• 23 customers mentioned a specific bug
• Execute generates the fix
• You ship it
• 23 customers are happy

It's not just about shipping faster. It's about shipping what customers are actually screaming for, instantly.

But now I'm trying to get people to actually use it and... nothing.

So either:

• People think their tools already do this (they don't)
• They're scared of AI-generated code (fair)
• They don't know it exists
• I'm explaining it wrong
• The free tier has some limitation I'm missing

I genuinely don't know.

But if you're a founder or dev reading this - would you use something that:

1. Organizes your scattered customer feedback
2. Shows you what customers are asking for most
3. Automatically generates code patches for reported bugs
4. Saves you 6+ hours per week

Or does that sound too sci-fi?

For almost 6 months we were stuck at around $8K MRR and honestly I had no clue why.

Acquisition was fine.
Retention wasnt terrible.
Customers liked the product.

But growth had completely slowed down.

I kept blaming positioning, timing, market conditions, all the usual founder copium lol.

Turns out the real issue was much simpler.

We were building random stuff nobody cared enough about.

A customer would casually mention a feature once and we'd immediately put it into the roadmap because somebody on the team "felt" it was important.

Then we'd launch it and almost nobody would use it.

At some point I got frustrated enough to go through months of customer feedback manually.

Emails.
Support tickets.
Slack messages.
Call notes.
Everything.

And I started counting how many times people mentioned the same problems.

One integration request showed up 23 times.

A feature we spent weeks building got mentioned like... twice.

That kinda broke my brain for a second because we already had the answers sitting in front of us the whole time.

We just never organized the feedback properly.

After that we changed the entire way we planned product decisions.

Every piece of feedback went into one place first.

Then we grouped similar requests together and looked at what kept repeating instead of what sounded smartest in meetings.

And honestly, roadmap discussions became way less emotional after that.

Funny enough, doing all this manually became exhausting pretty fast. We were wasting hours every week sorting feedback and counting mentions. So we started using this feedback tool we randomly found through X and it made the process way easier. Suddenly patterns became super obvious.

A few months after changing this process, things started moving again.

Churn dropped hard.
Customers started saying stuff like:
"Finally feels like you guys are listening."

Then referrals picked up.

Before this we'd get maybe 2 or 3 referrals a month.

Afterwards it jumped to around 12 to 15.

And about 6 months later we crossed $50K MRR.

No paid ads.
No growth hack.
No viral launch.

We just stopped building based on opinions and started paying attention to repeated customer pain.

The weird part is this sounds insanely obvious when you say it out loud.

But I swear most teams dont do it consistently because feedback is scattered everywhere and nobody wants to spend hours organizing it every week.

I used to think scaling came from better marketing.

Now I think a huge part of it is simply noticing what customers keep asking for over and over again before your competitors do.

(Written by me, polished by chatgpt)

Over the last 6 months, I went through around 150 SaaS products.

Looked at:

• Public roadmaps
• Customer reviews
• Changelogs
• Support complaints
• Founder posts
• What they shipped vs what users asked for

I was trying to figure out what separated products growing fast from products slowly dying.

Honestly, most of the stuff I expected to matter... didnt.

Product quality?
Helped, but wasnt the deciding factor.

Marketing?
Useful, but secondary.

Pricing?
Almost no clear pattern.

Team size?
Zero correlation.

But there was one thing every successful product had in common:

They shipped features customers genuinely needed.

Sounds obvious.

But the "needed" part is where most teams mess up.

Here's the pattern I kept seeing:

Failing products had a huge gap between:
"What customers kept asking for"
and
"What the team kept building"

Winning products had tight alignment between the two.

And weirdly, the winners were not better listeners.

They were better at seeing patterns.

That's the difference.

Most failed products already had enough customer feedback sitting around to make smarter decisions.

The feedback wasnt missing.

The organization was.

Example:

Product A gets hundreds of feature requests but everything is scattered across Slack, Intercom, emails, docs, random calls.

Team debates roadmap every week.
Still ships the wrong thing.

Product B gets almost the same amount of feedback.

But feedback goes into one system.
Tagged.
Grouped.
Counted.

They instantly know what keeps showing up.

Same feedback volume.
Different outcome.

We've been dealing with the same issue ourselves recently tbh. Too many convos happening everywhere. We started using this feedback product we found through X and suddenly repeat requests became way easier to notice. Felt kinda stupid we werent doing this earlier lol.

What I noticed about the winning teams:

Every single one had some way to centralize feedback.

Didnt matter what tool they used.

Some used spreadsheets.
Some used Notion.
Some built internal dashboards.

The system itself wasnt important.

The visibility was.

Every strong product team could answer this question in under 5 minutes:

"How many customers asked for this?"

The struggling teams couldnt.

And once you cross 100+ customers, this becomes a serious issue.

Because now feedback starts piling up faster than your team processes it.

The teams that process patterns faster move faster.

The teams that don't start guessing.

And guessing after product market fit starts getting expensive.

One metric stood out more than anything else:

Time between:
"Customer mentions problem"
to
"Feature gets shipped"

Fast teams:
2 to 4 weeks.

Slow teams:
3 to 6 months.

The correlation was honestly kinda insane.

Fast teams kept growing.

Slow teams kept falling behind.

But you cant move quickly if feedback is buried in 12 different places.

So I dont think the real advantage is "listening to customers."

I think the real advantage is seeing patterns before everyone else does.

Over the last 6 months, I went through around 150 SaaS products.

Looked at:

• Public roadmaps
• Customer reviews
• Changelogs
• Support complaints
• Founder posts
• What they shipped vs what users asked for

I was trying to figure out what separated products growing fast from products slowly dying.

Honestly, most of the stuff I expected to matter... didnt.

Product quality?
Helped, but wasnt the deciding factor.

Marketing?
Useful, but secondary.

Pricing?
Almost no clear pattern.

Team size?
Zero correlation.

But there was one thing every successful product had in common:

They shipped features customers genuinely needed.

Sounds obvious.

But the "needed" part is where most teams mess up.

Here's the pattern I kept seeing:

Failing products had a huge gap between:
"What customers kept asking for"
and
"What the team kept building"

Winning products had tight alignment between the two.

And weirdly, the winners were not better listeners.

They were better at seeing patterns.

That's the difference.

Most failed products already had enough customer feedback sitting around to make smarter decisions.

The feedback wasnt missing.

The organization was.

Example:

Product A gets hundreds of feature requests but everything is scattered across Slack, Intercom, emails, docs, random calls.

Team debates roadmap every week.
Still ships the wrong thing.

Product B gets almost the same amount of feedback.

But feedback goes into one system.
Tagged.
Grouped.
Counted.

They instantly know what keeps showing up.

Same feedback volume.
Different outcome.

We've been dealing with the same issue ourselves recently tbh. Too many convos happening everywhere. We started using this feedback product we found through X and suddenly repeat requests became way easier to notice. Felt kinda stupid we werent doing this earlier lol.

What I noticed about the winning teams:

Every single one had some way to centralize feedback.

Didnt matter what tool they used.

Some used spreadsheets.
Some used Notion.
Some built internal dashboards.

The system itself wasnt important.

The visibility was.

Every strong product team could answer this question in under 5 minutes:

"How many customers asked for this?"

The struggling teams couldnt.

And once you cross 100+ customers, this becomes a serious issue.

Because now feedback starts piling up faster than your team processes it.

The teams that process patterns faster move faster.

The teams that don't start guessing.

And guessing after product market fit starts getting expensive.

One metric stood out more than anything else:

Time between:
"Customer mentions problem"
to
"Feature gets shipped"

Fast teams:
2 to 4 weeks.

Slow teams:
3 to 6 months.

The correlation was honestly kinda insane.

Fast teams kept growing.

Slow teams kept falling behind.

But you cant move quickly if feedback is buried in 12 different places.

So I dont think the real advantage is "listening to customers."

I think the real advantage is seeing patterns before everyone else does.

Hot take:

Most teams prioritize features using the wrong signal.

They build based on whatever feedback is loudest, newest, or comes from the highest paid person in the room.

Not based on what customers keep asking for again and again.

And honestly, I think most roadmap frameworks are broken because of this.

The normal process looks something like this:

• Collect feature requests
• Rank by impact vs effort
• Build whatever scores highest

Sounds smart.

But half the time, "impact" is somebody's opinion dressed up as data.

You're asking:
"Does this feel important?"

Instead of:
"How many customers are repeatedly asking for this?"

Big difference.

The funny part is, most teams already have the answer sitting in front of them.

They just never organize feedback properly.

Customers tell you what hurts all the time.

Not directly. People are bad at explaining problems.

But patterns dont lie.

If 23 customers mention X and 2 mention Y, then X matters more. Simple.

But feedback lives everywhere.

Emails.
Slack messages.
Support tickets.
Call notes.
Random DMs.
Sales calls.

So your brain remembers the loudest complaint instead of the most common one.

We realised this after wasting months debating roadmap priorities in meetings that honestly went nowhere.

Now we centralize feedback and track frequency first before discussing anything.

We also started using this product we randomly found on X for organizing all of this and spotting repeat patterns faster. Funny enough, half our roadmap debates disappeared after that.

The fix is stupidly simple:

• Put all feedback in one place
• Tag similar requests together
• Count frequency
• Build the obvious winner

That's it.

And before someone says:
"What about RICE or MoSCoW?"

I get it.

But if your framework cant answer:
"How many customers asked for this exact thing?"

Then you're optimizing opinions, not demand.

Most teams are overthinking roadmap prioritization because the data feels messy.

But spending 1 hour organizing feedback saves weeks building the wrong thing.

We've learned this the hard way lol.

This is kinda embarrassing to admit, but here goes.

For 18 months, I thought I understood my product better than my customers did.

When someone said "This is confusing," I thought, "They'll understand once they use it more."

When they asked for a feature, I thought, "That's not the real problem."

When they complained, I thought, "These are early users. Serious users wont care about this."

I wasn't trying to ignore people. I believed in the vision too much.

And I thought listening to every piece of feedback was a bad way to build.

I was wrong.

Churn went from 3% to 7%.
We lost 3 customers to competitors.
Then my biggest customer, paying $3K/month, left too.

Their exact words:

"You never listen to what we tell you we need."
That one hurt because they were right.

So I went back and looked at everything properly.

Here's what I found:

• 23 people mentioned the same UX issue
• 7 customers asked for the same integration
• 5 support tickets every week talked about the same bug

I ignored all of it because the feedback was scattered everywhere.

Emails. Slack. Support tickets. Calls. Random DMs.

My brain focused on the loudest opinions instead of the most common ones.

The strange part?
I already had the feedback.

Customers were telling me the same things again and again. I simply never saw the pattern.

So we started using a simple product we found on X/twitter.
One place for all feedback.

Everything tagged by frequency.

Then the patterns became obvious almost instantly.

We built the top 3 requested fixes first.
- Churn dropped back to 3%.
- NPS went from 28 to 48.

We never got that $3K customer back. But we stopped losing customers for the same reason.

Biggest lesson from this:

Feedback is not random opinions.

It's your market showing you where friction exists.

Most founders dont ignore feedback because they dont care.

They ignore it because they cant see the pattern through all the noise.

Every founder I've spoken to says the same thing once they organize feedback properly:

"I didnt realize so many people were saying the same thing."

If you're guessing your roadmap right now, your answers are probably already sitting inside your support inbox.

I’m going to say something slightly controversial, most product roadmaps are kind of made up.

Not fake exactly. But pulled from places that aren’t really solid data.

This is what usually happens in product meetings:

CEO mentions something a customer asked last week.
Engineer says it’s a bad idea.
Someone brings up a competitor feature.
You go back and forth for a bit.
Then someone’s opinion wins.

You build it. It doesn’t really move anything. Then you sit there wondering why.

The issue isn’t that your team is bad at decisions. It’s that the input itself is incomplete.

You’re making calls on like 5 data points when you probably have 500 sitting somewhere.

Customers are already telling you what they want. Emails, support tickets, feature requests, calls. It’s all there. Just scattered.

So your brain naturally picks the loud stuff.
The angry email.
The big client asking for something.
The competitor move you just saw.

And you completely miss the quiet pattern.
Like 30+ customers asking for the same thing, just spread across weeks and different channels.

We didn’t realise this until we forced ourselves to actually see everything in one place. We started using this tool we randomly came across a while back, nothing fancy but it helped us pull everything into one view. That’s when things started clicking.

Here’s what changed for us:

Feature decisions weren’t about being smarter. It was just about visibility.

Once feedback was in one place, the roadmap kind of started deciding itself.

If something showed up in 8 customer messages + 3 support tickets + a couple calls, it wasn’t a debate anymore. It was obvious.

The system

• Everything goes into one inbox. Doesn’t matter where it comes from
• Tag it with frequency and context. Who said it, how often
• Look for patterns
• Build patterns, ignore outliers

What changed

• Decisions moved from gut feeling to actual signal
• We started building stuff people actually used
• Roadmap arguments dropped a lot because the data was right there

Honestly I think most teams don’t do this because it feels like a lot of work. Manual, messy, doesn’t scale.

And yeah it kind of is if you don’t have a setup.

We’re still figuring parts of it out tbh, but it’s way better than before.

Curious how others are handling this. Especially when feedback is coming from everywhere.
Are you guys using something specific to pull and organise all of it or still doing it manually?

Hi Folks, Reyansh here, solo founder.

I've been building software for clients and SaaS products for a while, and the same pattern kept showing up: a user or stakeholder reports a bug, the developer asks three follow-up questions ("which browser? what screen? can you screenshot?"), then spends 20 minutes reproducing it before they can even start fixing. Half the time the original report was so vague the dev gave up and waited for it to happen again.

So I built Feedzap. It's a script tag (~one line) you drop into any web product. Users click a button, point at the broken thing, type one sentence. The report that lands in your Linear/Jira/Slack includes the screenshot, the CSS selector of the element they clicked, the full URL, viewport, browser, and OS — automatically. No follow-ups needed.

It also connects with Linear/Jira/Slack and sends the tickets & AI Pattern summary to where your PM's live

The part I'm most interested in RMS's opinion on: Execute Fix. Instead of just routing the report as a ticket, it takes the captured context (selector, screenshot, description) and generates a code patch you can review before applying. It's right ~70% of the time on CSS/copy bugs from my testing, much less on logic bugs — but even when it's wrong, it gives the developer a starting point instead of a cold start. I'm not sure if this is genuinely useful or a gimmick, and I'd love honest takes.

Free tier is 20 reports/month, no credit card. The link goes straight to a demo you can break things on without signing up.

Things I'd love feedback on:

- Does Execute Fix feel useful or like AI-feature-creep?

- For those who've used BugHerd / Marker io / Usersnap / Feedovate - what's the friction that made you bounce or stay?

I'll be in the thread for the next ~12 hours. Ask me anything about how it's built or why I made specific calls.

Every week we get 20+ feature requests. Email, Slack, support tickets, customer calls. All over the place. So we can never see if 23 people asked for the same thing or just 1 person complained. - We spent more than $15K on just features & bugs no body wanted in my previous venture

We build features based on whoever was loudest, not what customers actually wanted.

What I built: Feedzap. Four things it does:

1. All feedback goes to one inbox (pulls from email, Slack, support, spreadsheets - doesn't matter)
2. Automatically tags it with frequency (how many times did people ask for this?)
3. You see patterns. Feature A = 23 requests. Feature B = 2 requests. Build A first.
4. AI executes the fix, essentially a claude code auto improving feedbacks

That's it. No complexity.

How it works:

• Import your existing feedback (or use sample data to test)
• See frequency tagging (automatically shows how many times each feature/complaint came up)
• Organize by customer tier (enterprise vs free user)
• Roadmap becomes obvious

Result: We went from 4 hours/week of manual organization to 30 minutes.

Built MVP, tested with ~50 founders.

Common feedback:

• "Immediately saw what customers actually want"
• "Stopped our pointless roadmap arguments"
• "Saved probably $5K in bad feature decisions"

Real questions for you:

1. Do you think this solves the actual problem (visibility of feedback patterns)?
2. Am I missing something obvious that founders need?
3. Would you use something like this if it was free?
4. What would make you NOT want to use it?

Free access right now if you want to test it and tell me if I'm on the right track.

Link in comments

Made it using the holy trinity (ClaudeCode + Supabase + Vercel)

I’m going to say something slightly controversial, most product roadmaps are kind of made up.

Not fake exactly. But pulled from places that aren’t really solid data.

This is what usually happens in product meetings:

CEO mentions something a customer asked last week.
Engineer says it’s a bad idea.
Someone brings up a competitor feature.
You go back and forth for a bit.
Then someone’s opinion wins.

You build it. It doesn’t really move anything. Then you sit there wondering why.

The issue isn’t that your team is bad at decisions. It’s that the input itself is incomplete.

You’re making calls on like 5 data points when you probably have 500 sitting somewhere.

Customers are already telling you what they want. Emails, support tickets, feature requests, calls. It’s all there. Just scattered.

So your brain naturally picks the loud stuff.
The angry email.
The big client asking for something.
The competitor move you just saw.

And you completely miss the quiet pattern.
Like 30+ customers asking for the same thing, just spread across weeks and different channels.

We didn’t realise this until we forced ourselves to actually see everything in one place. We started using this tool we randomly came across a while back, nothing fancy but it helped us pull everything into one view. That’s when things started clicking.

Here’s what changed for us:

Feature decisions weren’t about being smarter. It was just about visibility.

Once feedback was in one place, the roadmap kind of started deciding itself.

If something showed up in 8 customer messages + 3 support tickets + a couple calls, it wasn’t a debate anymore. It was obvious.

The system

• Everything goes into one inbox. Doesn’t matter where it comes from
• Tag it with frequency and context. Who said it, how often
• Look for patterns
• Build patterns, ignore outliers

What changed

• Decisions moved from gut feeling to actual signal
• We started building stuff people actually used
• Roadmap arguments dropped a lot because the data was right there

Honestly I think most teams don’t do this because it feels like a lot of work. Manual, messy, doesn’t scale.

And yeah it kind of is if you don’t have a setup.

We’re still figuring parts of it out tbh, but it’s way better than before.

Curious how others are handling this. Especially when feedback is coming from everywhere.
Are you guys using something specific to pull and organise all of it or still doing it manually?

I’m going to say something slightly controversial, most product roadmaps are kind of made up.

Not fake exactly. But pulled from places that aren’t really solid data.

This is what usually happens in product meetings:

CEO mentions something a customer asked last week.
Engineer says it’s a bad idea.
Someone brings up a competitor feature.
You go back and forth for a bit.
Then someone’s opinion wins.

You build it. It doesn’t really move anything. Then you sit there wondering why.

The issue isn’t that your team is bad at decisions. It’s that the input itself is incomplete.

You’re making calls on like 5 data points when you probably have 500 sitting somewhere.

Customers are already telling you what they want. Emails, support tickets, feature requests, calls. It’s all there. Just scattered.

So your brain naturally picks the loud stuff.
The angry email.
The big client asking for something.
The competitor move you just saw.

And you completely miss the quiet pattern.
Like 30+ customers asking for the same thing, just spread across weeks and different channels.

We didn’t realise this until we forced ourselves to actually see everything in one place. We started using this tool we randomly came across a while back, nothing fancy but it helped us pull everything into one view. That’s when things started clicking.

Here’s what changed for us:

Feature decisions weren’t about being smarter. It was just about visibility.

Once feedback was in one place, the roadmap kind of started deciding itself.

If something showed up in 8 customer messages + 3 support tickets + a couple calls, it wasn’t a debate anymore. It was obvious.

The system

• Everything goes into one inbox. Doesn’t matter where it comes from
• Tag it with frequency and context. Who said it, how often
• Look for patterns
• Build patterns, ignore outliers

What changed

• Decisions moved from gut feeling to actual signal
• We started building stuff people actually used
• Roadmap arguments dropped a lot because the data was right there

Honestly I think most teams don’t do this because it feels like a lot of work. Manual, messy, doesn’t scale.

And yeah it kind of is if you don’t have a setup.

We’re still figuring parts of it out tbh, but it’s way better than before.

Curious how others are handling this. Especially when feedback is coming from everywhere.
Are you guys using something specific to pull and organise all of it or still doing it manually?

I’m going to say something slightly controversial, most product roadmaps are kind of made up.

Not fake exactly. But pulled from places that aren’t really solid data.

This is what usually happens in product meetings:

CEO mentions something a customer asked last week.
Engineer says it’s a bad idea.
Someone brings up a competitor feature.
You go back and forth for a bit.
Then someone’s opinion wins.

You build it. It doesn’t really move anything. Then you sit there wondering why.

The issue isn’t that your team is bad at decisions. It’s that the input itself is incomplete.

You’re making calls on like 5 data points when you probably have 500 sitting somewhere.

Customers are already telling you what they want. Emails, support tickets, feature requests, calls. It’s all there. Just scattered.

So your brain naturally picks the loud stuff.
The angry email.
The big client asking for something.
The competitor move you just saw.

And you completely miss the quiet pattern.
Like 30+ customers asking for the same thing, just spread across weeks and different channels.

We didn’t realise this until we forced ourselves to actually see everything in one place. We started using this tool we randomly came across a while back, nothing fancy but it helped us pull everything into one view. That’s when things started clicking.

Here’s what changed for us:

Feature decisions weren’t about being smarter. It was just about visibility.

Once feedback was in one place, the roadmap kind of started deciding itself.

If something showed up in 8 customer messages + 3 support tickets + a couple calls, it wasn’t a debate anymore. It was obvious.

The system

• Everything goes into one inbox. Doesn’t matter where it comes from
• Tag it with frequency and context. Who said it, how often
• Look for patterns
• Build patterns, ignore outliers

What changed

• Decisions moved from gut feeling to actual signal
• We started building stuff people actually used
• Roadmap arguments dropped a lot because the data was right there

Honestly I think most teams don’t do this because it feels like a lot of work. Manual, messy, doesn’t scale.

And yeah it kind of is if you don’t have a setup.

We’re still figuring parts of it out tbh, but it’s way better than before.

Curious how others are handling this. Especially when feedback is coming from everywhere.
Are you guys using something specific to pull and organise all of it or still doing it manually?

I’m going to say something slightly controversial, most product roadmaps are kind of made up.

Not fake exactly. But pulled from places that aren’t really solid data.

This is what usually happens in product meetings:

CEO mentions something a customer asked last week.
Engineer says it’s a bad idea.
Someone brings up a competitor feature.
You go back and forth for a bit.
Then someone’s opinion wins.

You build it. It doesn’t really move anything. Then you sit there wondering why.

The issue isn’t that your team is bad at decisions. It’s that the input itself is incomplete.

You’re making calls on like 5 data points when you probably have 500 sitting somewhere.

Customers are already telling you what they want. Emails, support tickets, feature requests, calls. It’s all there. Just scattered.

So your brain naturally picks the loud stuff.
The angry email.
The big client asking for something.
The competitor move you just saw.

And you completely miss the quiet pattern.
Like 30+ customers asking for the same thing, just spread across weeks and different channels.

We didn’t realise this until we forced ourselves to actually see everything in one place. We started using this tool we randomly came across a while back, nothing fancy but it helped us pull everything into one view. That’s when things started clicking.

Here’s what changed for us:

Feature decisions weren’t about being smarter. It was just about visibility.

Once feedback was in one place, the roadmap kind of started deciding itself.

If something showed up in 8 customer messages + 3 support tickets + a couple calls, it wasn’t a debate anymore. It was obvious.

The system

• Everything goes into one inbox. Doesn’t matter where it comes from
• Tag it with frequency and context. Who said it, how often
• Look for patterns
• Build patterns, ignore outliers

What changed

• Decisions moved from gut feeling to actual signal
• We started building stuff people actually used
• Roadmap arguments dropped a lot because the data was right there

Honestly I think most teams don’t do this because it feels like a lot of work. Manual, messy, doesn’t scale.

And yeah it kind of is if you don’t have a setup.

We’re still figuring parts of it out tbh, but it’s way better than before.

Curious how others are handling this. Especially when feedback is coming from everywhere.
Are you guys using something specific to pull and organise all of it or still doing it manually?

Scaling PMs all hit this at some point. Once you start getting real traction, feature requests just don’t stop. They keep coming.

We went from like 5 requests a month to 20+ every week. Customers messaging us, support logging tickets, random stuff in Slack, everywhere basically.

Our first thought was “ok we need a better tracking system”. But that didn’t really fix it. We still had 200+ requests sitting there with no clear way to prioritise.

So we had to be real about it. How do you say no to 190 things and yes to 10.

Here’s what we actually started doing:

Step 1: Batch by theme
We grouped similar stuff together.
All "dark mode" requests in one bucket. Same for "integration with X", "performance issues", etc.

Takes like 30 mins max but gives you a proper high level view.

Step 2: Frequency check
Patterns show up fast.

"Performance" came up 34 times.
"Dark mode" maybe 5 times.

This alone cut down our list a lot. Like 60% clarity just from this.

Step 3: Customer segment weight
Not all requests are equal.

Free user: 1x
Paying customer: 3x
Enterprise: 5x
Customer close to churning: 10x

5 enterprise users asking for something hits very different vs 5 free users.

Step 4: Look for blockers
Is this stopping people from using the product? Or just nice to have?

Blockers always go first.

The result
We went from “which 200 things do we ignore” to “which 10 actually matter right now”.

Backlog is still big, that never really goes away. But roadmap feels way cleaner now. More signal, less noise.

What surprised us
One angry customer used to influence us way more than they should’ve.

But once we actually organised things, a quiet request that came from 5 different companies mattered way more. We just couldn’t see that earlier.

Before this, loud = priority. Which is kind of dangerous tbh.

The actual workflow
This used to take us like 4 hours every week. Copying stuff into sheets, tagging manually, scoring everything by hand. Pretty painful.

We’ve made it way faster now with a tool we found on X, but I’m still curious how others are doing this without spending hours on it every week.

Genuinely asking, what are you guys using to manage this at scale? Anything that actually works in real life and not just in theory?