Six months into running my SaaS, my "feedback system" was three browser tabs, a starred Gmail folder, and a sticky note on my monitor that said "check Discord."

That was the whole system.

It held together until the day I found a three-paragraph email from a paying user — a genuinely detailed feature request with a real use case — sitting unread for 24 days. His last line was: "Happy to pay more if you can support this."

I replied the same afternoon I found it.

His reply: "Switched last week, thanks anyway."

That was the moment I stopped treating feedback management as a nice-to-have.

Why the usual fixes didn't fix anything

I tried the obvious things first. I want to document them because I see a lot of people cycling through the same failed solutions.

Notion database 🪦

Built a beautiful one. Color-coded tags, priority columns, status tracking. It lasted 11 days before nobody — including me — was maintaining it. The friction of "open Notion, find the right database, fill in six fields" is invisible when you're designing the system and fatal when you're in the middle of a support conversation.

Airtable form 🪦

Better entry point, still disconnected from where users actually were when they had feedback. Nobody bookmarks your Airtable form. They DM you on Discord and you think "I'll add that later" and you don't.

Canny — this one actually worked, for a while

I genuinely liked Canny. Clean interface, users could upvote requests, I could see what was popular. It felt like a real system.

Then our user count grew and the pricing tier jumped. I was looking at $99/month for a feedback board for a product still finding its footing. That's not a moral judgment on Canny — it's a fair product — but for a bootstrapped indie dev, it started feeling like a tax on momentum.

The deeper problem with all three solutions was the same: they were inboxes, not loops.

User submits → enters the void → user never knows if anyone saw it → user assumes nobody did → trust erodes → churn.

I had built a place to receive feedback. I had not built a way to respond to it at scale.

What I was actually looking for

Before I started evaluating new tools, I wrote down what a real system needed to do:

1. One place for feedback from every channel
   (Discord, email, in-app, wherever)

2. Something that helps me find signal in the noise
   (not just more data — actual insight)

3. A way for users to see that their input matters
   (visibility into what's planned)

4. Proof that the product is alive and improving
   (something users can point to)

Most tools I evaluated checked box 1. A few checked box 2. Almost none addressed 3 and 4 — which, in retrospect, are the ones that actually affect retention.

Finding FeedLog

I found FeedLog the way I find most good tools: buried in a Reddit comment thread.

Someone asked for Canny alternatives in r/SaaS. A reply mentioned FeedLog — open-source, self-hostable, AI-powered deduplication. I clicked with low expectations.

The GitHub repo: https://github.com/linkcraftstudio/feedlog

What I found wasn't a half-finished side project. It was a complete platform built around three modules that mapped almost exactly to my list:

I deployed the Vercel version in about 20 minutes. (They also support Docker and Cloudflare Workers — I've since moved to Docker on my own VPS for data sovereignty reasons, which I'll get to.)

The setup, honestly

No sugarcoating here because I know devs hate vague "it was easy!" writeups.

Vercel deploy: Fork the repo, connect to Vercel, set your environment variables (database URL, NextAuth secret, OpenAI API key for AI features), deploy. The README is clear. I hit one issue with the DB migration step that I resolved by checking the GitHub Issues — someone had the same problem two weeks earlier, fix was already there.

Environment variables you'll need:

DATABASE_URL=             # PostgreSQL connection string
NEXTAUTH_SECRET=          # run: openssl rand -base64 32
NEXTAUTH_URL=             # your deployment URL
OPENAI_API_KEY=           # for AI dedup/classification (optional but worth it)

Time to first feedback submitted: About 35 minutes from zero.

Docker self-host (what I use now):

git clone https://github.com/linkcraftstudio/feedlog.git
cd feedlog
cp .env.example .env
# edit .env with your values
docker compose up -d
docker compose exec server npx prisma migrate deploy

Running on a $6/month VPS. Total infra cost including the server: ~$8/month with OpenAI usage. Previous Canny cost: $99/month.

What actually changed — with specifics

The dedup surfaced a blind spot

When I migrated historical feedback into FeedLog, the AI clustered roughly 65 items into 24 distinct themes.

One cluster had 13 entries from 13 different users, all describing the same workflow gap in completely different language. I had mentally registered that problem as "two or three people mentioned this." It was our single most-requested improvement, invisible to me because each signal arrived in a different channel with different wording.

That cluster went straight to the top of our next sprint. We shipped it three weeks later. The users who had submitted that feedback got a Changelog notification that explicitly referenced their requests. Two of them upgraded their plans within the same week.

I can't prove causation. But I notice the correlation.

The public Roadmap changed the conversation dynamic

Before: Discord was full of "any update on X?" and "is Y on the roadmap?" messages. Each one required a manual response. Each unanswered one was a small withdrawal from the trust account.

After: I pointed users to the public Roadmap. The "when is X coming?" traffic dropped noticeably. Users who wanted to know where things stood could find out themselves.

What I didn't expect: users started commenting on Roadmap items. Not just checking — participating. The Roadmap became a live conversation rather than a static list. Users who engaged with it in this way felt more invested in the product. That's not a metric I track, but I feel it in the texture of the community.

Changelog entries closed loops I didn't know were open

Every release, I now write a FeedLog Changelog entry. Not just "v2.3 released." Specifically:

"You asked for [X]. We built it. Here's how it works."

A user whose feature request was referenced in a Changelog replied in Discord: "You actually shipped it. That doesn't happen."

That response tells you everything about how low the bar is. Users have learned to expect silence. When you close the loop with evidence, it registers.

The data ownership piece (this mattered to me)

User feedback is not just operational data. It's strategic intelligence.

It tells you what users actually want, how they think about problems, which competitors they're comparing you to, and what frictions are closest to causing churn. Having all of that sitting on a third-party SaaS platform — accessible by their team, subject to their pricing changes, vulnerable to their acquisition or shutdown — is a risk that grows as your product becomes more valuable.

FeedLog self-hosted means that data is on my infrastructure. MIT licensed code means I can see exactly what runs. No vendor lock-in, no pricing surprises as we scale.

This might sound like an edge concern for an early-stage product. I've started thinking of it as hygiene.

Honest limitations

I want to be useful here, not just promotional:

• Integration ecosystem: No native Slack or Discord sync yet. I handle this with a simple webhook but it requires some setup.
• Mobile admin UX: Functional, not polished. I review feedback on desktop.
• Community size: Smaller than Canny's. GitHub Issues is responsive, but you're not getting 24/7 enterprise support.
• Age: It's a younger project. Some edges are rougher than a tool that's had years of polish.

If you need deep CRM integrations, advanced user segmentation by plan tier, or SLA-backed support on day one — Canny is probably still your tool. FeedLog is built for teams where the dev and the product manager are sometimes the same person.

Summary: what the stack looks like now

Feedback channels:  Discord → FeedLog widget → Feedback board
                    Email   → forwarding rule → Feedback board
                    In-app  → embedded widget → Feedback board

Processing:         AI dedup + clustering (weekly review)
                    Manual prioritization based on cluster size

User communication: Public Roadmap (what's planned)
                    Changelog (what shipped, tied to requests)

Infrastructure:     Docker on $6/mo VPS
                    PostgreSQL (bundled)
                    OpenAI API for AI features (~$2/mo)

Total cost:         ~$8/month
Previous cost:      $99/month

The actual lesson

The problem I had wasn't that I lacked a place to collect feedback. I had several places.

The problem was that feedback collection and feedback response are two different capabilities, and I had built one while ignoring the other.

FeedLog is the first tool I've used that treats both halves as equally important — and connects them through a public-facing Roadmap and Changelog that make the loop visible to users, not just to the team.

That visibility is what changes user behavior. Not the tooling. The transparency.

→ https://feedlog.ai/
→ GitHub (⭐ appreciated): https://github.com/linkcraftstudio/feedlog

How are you currently managing feedback across multiple channels? Genuinely curious — drop your setup in the comments. Especially interested if anyone has found a clean Discord-to-feedback-board pipeline.