AI-Powered Feature Voting & Public Roadmap Board for SaaS Founders

• The Opportunity: SaaS founders need feature request collection, user voting, and public roadmaps, but Canny charges $79-359/mo, UserVoice wants $699+/mo, and Aha! costs $249/user/mo, leaving indie hackers with no affordable, AI-enhanced option
• The Gap: The feedback management market is bifurcated: enterprise tools ($99-699/mo) with overwhelming complexity, or bare-bones open-source options (Fider) requiring self-hosting, nothing in the $15-39/mo range with AI features
• The Solution: An AI-powered feature voting board that auto-categorizes feedback, merges duplicate requests, generates changelog entries from completed features, and displays a beautiful embeddable public roadmap, for $15-39/month
• Revenue Potential: Conservative $9K MRR within 12 months from 450+ SaaS founders, scaling to $50K+ MRR as the tool becomes the default for indie SaaS
• Buildability: Easy difficulty, feedback boards, upvoting, and kanban roadmaps are basic CRUD operations with a voting layer. A solo developer can ship a polished MVP in 2-3 weeks
• Why Now: Canny recently restructured pricing to $79/mo minimum (paywalling integrations behind their $359/mo Growth plan), thousands of "vibe coded" SaaS products launching monthly all need feedback infrastructure, and AI can now auto-categorize and deduplicate feedback intelligently

The Problem & Opportunity

Every great SaaS product starts with a real, painful problem. Here's the core gap in the market and why the timing makes this opportunity compelling right now.

🎯 The Opportunity

Every SaaS product, from a $500 MRR indie tool to a $50M ARR enterprise platform, needs a systematic way to collect feature requests from users, let them vote on what matters most, and communicate what's being built through a public roadmap. This isn't optional. It's fundamental product management infrastructure.

Without it, founders drown in a chaotic mix of feedback from Slack messages, support emails, Twitter replies, Intercom chats, and in-person conversations. Features get built based on whoever complained loudest rather than what the majority actually needs. Users feel unheard and churn. The product roadmap becomes invisible, so users don't know if their requested feature is coming tomorrow or never.

The tools that solve this problem exist, but they're priced for well-funded startups and enterprises. The current landscape looks like this:

• Canny: Free plan with severe limits (50 tracked users), Starter at $79/month, Growth at $359/month, Business with custom (enterprise) pricing. PM integrations, automations, and user segmentation all locked behind the $359/month Growth plan.
• UserVoice: Minimum $699/month with no free or self-serve option. The minimum plan gives you "super basic features" according to Savio's analysis, while the features most teams need cost $1,333/month.
• ProductBoard: $19-59 per "maker" per month, seemingly affordable until you realize a 3-person team pays $177/month, and the AI features cost extra.
• Aha! Ideas: $39-149 per user per month, $39/user/month for even a small team, with enterprise complexity that's overkill for a 2-person SaaS startup.

For an indie hacker making $3,000 MRR, paying $79-359/month for a feature voting board is absurd. That's 2.6-12% of gross revenue for what is, at its core, a list of ideas with upvote buttons and a kanban board. So most founders resort to terrible workarounds: a Google Form linked to a spreadsheet, a Notion page nobody visits, a #feature-requests channel in Discord that becomes an unsearchable graveyard, or simply asking users to "just email us."

The product management software market reached $12.5 billion in 2024 and is growing at 12.4% CAGR. Within this, the feedback management and feature voting sub-segment is estimated at $800M+ and growing faster than the overall market. Yet the affordable end ($15-50/month) is massively underserved.

The timing is perfect: thousands of new SaaS products launch monthly thanks to AI-assisted "vibe coding" tools (Cursor, Bolt, Lovable, Replit Agent). Every one of these products will eventually need to collect user feedback and share a roadmap. If you build the affordable, AI-powered default, the tool that indie hackers recommend to each other, you capture this entire wave.

👤 Ideal Customer Profile

Primary Target: Indie SaaS Founders & Solo Developers

• Running a SaaS product with 50-5,000 users
• MRR between $500-15,000, too early for enterprise tools, too established for "just email me"
• Currently using Notion, Google Forms, Discord channels, or GitHub Issues for feature requests
• Technically capable but want a dedicated, polished solution
• Price sensitivity: willing to pay $15-29/month for a tool that visibly improves their product development process

Secondary Target: Small SaaS Teams (2-5 People)

• Product + engineering team that needs organized feedback
• Currently using Canny free tier and hitting limitations, or considering Canny paid but hesitating at $79/month
• Need team collaboration: assign feature requests to team members, comment internally
• Willing to pay $29-59/month for a proper feedback management system

Tertiary Target: Open-Source Project Maintainers

• Managing open-source projects with active communities
• Need to organize feature requests beyond GitHub Issues
• Want a public roadmap to communicate priorities to contributors
• Price-sensitive: need a generous free tier or very affordable paid plan

Trigger Events:

1. User emails asking "are you going to build X?" and the founder realizes they have no public way to collect and track requests
2. Founder builds the wrong feature because they listened to the loudest voice instead of the most-voted request
3. A competitor launches a public roadmap page and users praise the transparency
4. They evaluate Canny, see the $79/month starting price, and search for alternatives
5. They try Fider (open-source) but don't want to manage infrastructure

🔥 Why Now

Canny's Pricing Restructure: Canny recently restructured their pricing, moving key features like PM integrations (Jira, Linear, Asana), user segmentation, automations, and advanced privacy behind their $359/month Growth plan. Their free plan now tracks only 50 users, barely enough for a beta product. This pricing move is actively pushing cost-conscious founders to search for alternatives.

The Vibe Coding Wave: AI coding tools (Cursor, Bolt, Lovable, Replit Agent) are enabling thousands of new SaaS products to launch every month. These products are built fast but need infrastructure for everything, including feedback collection and roadmaps. The "vibe coder" audience is cost-sensitive ($0-20/month per tool) and needs plug-and-play solutions.

AI Makes Feedback Management Smarter: Traditional feature voting boards are passive, they display what users submit and that's it. AI changes the game: auto-categorize feedback into themes, detect and merge duplicate requests (a massive pain point with manual boards), summarize trends across hundreds of requests, auto-generate changelog entries from completed features, and even suggest which features to prioritize based on voter demographics and retention data. This is genuinely new capability.

Public Roadmaps Became Expected: Users now expect SaaS products to have public roadmaps. Tools like Linear popularized the "build in public" movement. Products without visible roadmaps are perceived as less transparent and trustworthy. This creates demand not just from product managers, but from founders who see roadmaps as marketing assets.

UserVoice's Enterprise-Only Pivot: UserVoice moved exclusively upmarket, $699/month minimum, no self-serve, sales-only process. This vacated the SMB market entirely. Savio's analysis explicitly states UserVoice alternatives can "save your SaaS startup $15,000 a year." That displaced demand needs somewhere to go.

📊 Validation & Proof

Real market signals and community evidence that confirm this problem is widespread, actively searched for, and underserved by existing solutions.

Demand Signals

The demand for affordable feature voting and roadmap tools is consistently strong across SaaS communities:

In this r/SaaS discussion, users compare feature request and voting tools, noting that Canny's free plan is limited and pricing scales quickly.

In this r/SaaS thread, SaaS founders discuss customer feedback tools, with several noting frustration over tools that either lack features on free tiers or overcharge for basics.

In this r/SaaS discussion, a team shares their affordable Canny alternative targeting early-stage SaaS companies with simpler UI and similar features.

In this r/SideProject thread, a developer shares their Canny competitor — a feature voting tool that helps build a community around products — and reports early revenue success.

In this r/webdev discussion, developers seek Canny.io alternatives with custom domains, embeddable public roadmaps, and more affordable pricing.

In this r/SaaS thread, users discuss simple feature voting tools that support guest submissions without account creation.

In this r/SaaS discussion, SaaS teams discuss how they collect and manage in-app user feedback, comparing lightweight board tools for feature requests and voting.

In this r/SaaS thread, users debate whether hybrid feedback tools are the future, comparing Canny, Typeform, and newer AI-driven approaches.

In this r/ProductManagement discussion, product managers discuss why some teams skip dedicated feedback tools like Canny and Aha, preferring direct community engagement instead.

In this r/SaaS thread, SaaS founders compare user feedback tools, frustrated by high pricing for basic NPS, CSAT, and survey functionality.

In this r/ProductMarketing discussion, product marketers discuss feedback tools for SaaS, cautioning against enterprise tools like Pendo or FullStory for early-stage products.

In this r/indiehackers thread, indie hackers compare platforms for gathering feature requests, including Canny, featureOS, and alternatives.

Market Proof

1. Multiple indie hackers are building Canny alternatives independently: UserJot, ProductLift, Featurebase, RightFeature, Supahub, Feedbear, and Nolt all emerged because founders found Canny too expensive. This independent convergence is the strongest possible demand signal.

2. One indie dev posted "I made a Canny competitor and it's making money!!" on r/SideProject, directly validating that this market can sustain profitable indie products.

3. UserJot's founder explicitly said he "got frustrated with this exact problem": the gap between Canny's free tier and its $79+/month paid plans. He's now building a profitable business in this space.

4. Canny raised $4M+ in funding and serves thousands of companies, proving the market is large and growing. If just the visible tip serves thousands, the total addressable market of SaaS products needing feedback tools is massive.

5. The "Canny alternative" and "Canny pricing" keywords have significant search volume, indicating active demand from users actively seeking cheaper options. UserJot built an entire SEO strategy around "Canny pricing 2026" content.

6. Product management software market: $12.5B in 2024, 12.4% CAGR (Allied Market Research). The feedback and feature voting sub-segment within this is estimated at $800M+ and growing as more SaaS products launch.

The Market

Understanding the competitive landscape reveals where incumbents are overcharging, underserving, or missing entire customer segments, and exactly where to position.

🏆 Competitive Landscape

The feature voting and roadmap space has clear tiers with a significant gap at the affordable, AI-powered end:

Enterprise Tier ($249+/month)

• UserVoice ($699-1,333/mo): The original feature request tool. Now fully enterprise, no free plan, no self-serve, sales-only. "Super basic features" at $699/month, real functionality at $1,333/month. Not relevant for indie hackers.
• Aha! Ideas ($39-74/user/mo, Essentials from $39/user/mo): Comprehensive product management suite. Feature requests are just one module. Extremely complex for a founder who just wants a voting board.
• Canny Growth ($359/mo): Canny's tier with PM integrations, automations, segmentation, and unlimited roadmaps. The price you actually need to pay for Canny's full value.
• ProductBoard ($19-59/maker/mo, ~$177+/mo for teams): Product management platform with insights, roadmaps, and prioritization. Per-maker pricing makes it expensive for teams. AI features cost extra.

Mid-Market Tier ($79-149/month)

• Canny Starter ($79/mo): Basic feedback boards, 1 roadmap, 1,000 tracked users. No PM integrations, no automations, no segmentation. Limited for the price.
• Frill Business ($149/mo): All-in-one feedback, roadmap, and changelog tool. Good feature set but premium pricing for small teams.
• Featurebase Growth ($99/mo): Direct Canny alternative. Feedback boards, roadmap, changelog, AI duplicate detection. Growing fast by undercutting Canny.

Budget Tier ($15-49/month)

• Sleekplan ($15-65/mo): Affordable feedback widget. Basic voting and roadmap. Limited AI features.
• ProductLift ($14-29/mo): Simple feedback boards. Clean UI but limited feature set.
• Nolt ($25-50/mo): Simple feedback boards with voting. No AI features, limited integrations.
• UserJot (Free-$29/mo): Generous free tier. Feedback boards, roadmap, changelog. Growing but limited AI.

Self-Hosted / Free

• Fider (Free, open-source): Self-hosted feature voting. Requires managing infrastructure. No AI, no managed hosting, no support.
• GitHub Issues (Free): Works for developer audiences but terrible UX for non-technical users, no voting system, no public roadmap view.

The Gap: Nobody offers an AI-powered feature voting board in the $15-39/month range with: (1) AI duplicate detection and auto-categorization, (2) AI-generated changelogs from completed features, (3) embeddable feedback widget for any web app, (4) beautiful public roadmap page, (5) integration with common tools (Linear, GitHub, Slack), and (6) a generous free tier to capture early-stage founders. The budget tools lack AI; the AI-capable tools charge $79-359/month.

🌊 Blue Ocean Strategy

Instead of building another Canny clone with cheaper pricing, the AI Feature Board should create genuinely new value:

Eliminate:

• Per-tracked-user pricing that punishes growth (Canny's approach)
• Enterprise complexity (SSO, audit logs, SCIM provisioning)
• Sales-required onboarding (UserVoice requires a sales call just to see pricing)
• Separate changelog tool (consolidate feedback + roadmap + changelog in one)

Reduce:

• Setup time from hours to 5 minutes (widget installation + board creation)
• Feature request management overhead from daily inbox triage to weekly AI-summarized reviews
• Duplicate request noise from 40%+ duplicates to near-zero (AI auto-merges)
• Roadmap update effort from manual status changes to auto-sync with Linear/GitHub

Raise:

• AI intelligence: auto-categorize, deduplicate, summarize, and prioritize feedback
• Public roadmap quality: beautiful, branded, embeddable roadmap that doubles as marketing
• Changelog automation: turn completed features into beautiful changelog entries with one click
• Speed-to-insight: "What do our users want most?" answered in seconds, not hours

Create:

• AI Duplicate Detector: When a user submits "add dark mode," the AI recognizes it matches 3 existing requests for "dark theme," "night mode," and "dark color scheme", and merges them automatically, consolidating votes
• AI Feedback Summarizer: Weekly digest that says "This week, 47 new requests came in. Top themes: mobile app (23), API access (12), team features (8). Sentiment shift: billing complaints up 40% vs. last week."
• One-Click Changelog: When you mark a feature as "Complete" on the roadmap, AI auto-generates a changelog entry with title, description, and tags, ready to publish
• Embedded Feedback Widget: A lightweight JavaScript widget that pops up inside your SaaS app, letting users submit feedback and vote without leaving your product
• Smart Prioritization Score: AI combines vote count, voter revenue (if integrated with Stripe), recency, and sentiment to generate a "Priority Score" for each feature request

Devil's Advocate

Before committing, stress-test the thesis. Here are the toughest objections a skeptic would raise, and why this opportunity still holds up under scrutiny.

🤔 Tough Questions

Q1: "Can't founders just use GitHub Issues or a Notion page for free?" They can, and most do, initially. But GitHub Issues has terrible UX for non-technical users (your customers aren't developers), no voting system, and no public roadmap view. Notion pages are invisible, users don't visit them, and there's no notification system when a feature ships. The real comparison isn't free vs. $15/month, it's "chaotic, invisible feedback" vs. "organized, AI-enhanced, publicly visible feedback that reduces churn." A founder losing $500/month to churn because users feel unheard can easily justify $15/month for a tool that demonstrably improves retention.

Q2: "UserJot already exists with a generous free tier. Why build another one?" UserJot is one indie tool in a market that supports dozens of profitable businesses. Canny has thousands of customers at $79-359/month. UserJot, ProductLift, Nolt, Sleekplan, they're all growing simultaneously because the market is massive. FeedbackPilot differentiates on AI: auto-categorization, duplicate detection, changelog generation, and weekly digests. These are genuine productivity features, not cosmetic differences. The market is not winner-take-all; it's grow-with-the-market.

Q3: "The 'AI-powered' positioning might feel like a gimmick. Most AI features are underwhelming." The AI features in FeedbackPilot solve concrete, measurable problems: (1) Duplicate detection eliminates 30-40% of manual triage work. (2) Auto-categorization removes the need to manually tag every request. (3) Changelog generation saves 20-30 minutes per entry. (4) Weekly digest replaces 2+ hours of manual feedback review. These aren't "ask AI anything" features, they're specific, automated workflows that save measurable time. The value is obvious from day one.

Q4: "What prevents Canny from copying your AI features?" Canny already has some AI features (AI Autopilot), but they're locked behind the $359/month Growth plan. Their incentive is to keep AI as a premium upsell, not to give it away on a cheap plan. FeedbackPilot's advantage is that AI features are included starting at $15/month, making the value proposition fundamentally different. Canny can't offer AI at $15/month without cannibalizing their $359/month tier.

Q5: "Feedback management tools have notoriously high churn. Users set them up and forget about them." This is a real concern, but the AI weekly digest directly addresses it. Every Monday, the founder gets a summary email: "23 new requests, top themes: mobile app (12), API access (8). Your roadmap has 3 overdue items." This keeps the tool visible and valuable without requiring the founder to log in. Additionally, the public roadmap and changelog create ongoing value, they're marketing assets that work passively. The stickiest feature is the vote data itself: months of accumulated user votes become irreplaceable institutional knowledge.

Q6: "Isn't $15/month too cheap to be sustainable?" At $15/month with 89% gross margin, each customer generates $13.35/month in profit. Infrastructure costs are minimal because feature boards are simple CRUD operations, the most expensive part is AI inference, which costs ~$0.40/customer/month. A solo developer needs just 200 paying customers ($3,000 MRR) to cover all personal and business expenses. At 500 customers ($7,500 MRR), it's a comfortable full-time income. The low price point actually enables faster growth through word-of-mouth and lower acquisition costs.

The Solution

The product vision is focused on doing one thing exceptionally well: solving the core problem without the complexity and bloat of enterprise incumbents.

💡 Product Vision

FeedbackPilot (working name) is an AI-powered feature voting, public roadmap, and changelog platform designed for indie SaaS founders who need professional feedback management without the enterprise price tag. Collect feature requests with an embeddable widget, let users vote on priorities, share a beautiful public roadmap, and auto-generate changelogs, all powered by AI that categorizes, deduplicates, and summarizes feedback.

Core Value Proposition: "Know exactly what your users want. AI-powered feature voting, public roadmaps, and changelogs for $15/month, not $359."

Key Features (MVP):

1. Feedback Boards: Create multiple boards (Feature Requests, Bug Reports, Ideas) where users can submit and vote on posts. Guest voting (no signup required) or authenticated voting. Sort by votes, recency, trending. Tag and categorize posts.

2. AI Duplicate Detection: When a user submits new feedback, AI scans existing posts and suggests merges. "This looks similar to 3 existing requests, merge votes?" Reduces noise by 30-50%.

3. Public Roadmap: Beautiful, embeddable roadmap page with kanban columns (Planned → In Progress → Complete). Custom domain support. Toggle visibility per feature. Branded with your company colors and logo.

4. AI-Powered Changelog: When a feature moves to "Complete," AI auto-generates a changelog entry with professional copy. One click to publish. Historical changelog feed on your public roadmap page.

5. Embeddable Widget: Lightweight JavaScript widget that overlays on your SaaS app. Users submit feedback and vote without leaving your product. Customizable trigger button, branding, and fields.

6. AI Weekly Digest: Every Monday morning, receive an AI summary: top new requests, vote trends, sentiment shifts, recommended priorities. Replace hours of manual feedback triage with a 2-minute read.

7. Integrations: Two-way sync with Linear and GitHub Issues. Slack notifications for new high-vote requests. Webhook support for custom integrations.

🔄 User Flow

🚀 MVP Roadmap

Week 1: Core Feedback Engine

• Next.js app with Supabase authentication
• Database schema: workspaces, boards, posts, votes, comments, roadmap items
• Feedback board CRUD: create board, submit post, upvote/downvote, comment
• Public board page with sorting (top, new, trending) and filtering by status/category
• Admin dashboard: manage posts, change status, add internal notes
• Basic widget scaffolding (JavaScript snippet for embedding)

Week 2: Roadmap, Changelog & AI

• Public roadmap page: kanban view (Planned → In Progress → Complete)
• Roadmap management: drag-and-drop status changes, link to feedback posts
• Changelog feed: create entries (title, body, tags), display on public page
• AI duplicate detection: on new post submission, find similar posts using embeddings/AI
• AI auto-categorization: tag new posts with relevant categories automatically
• AI changelog generator: from completed feature → generate changelog copy

Week 3: Widget, Integrations & Polish

• Embeddable JavaScript widget: overlay on any web app, submit feedback + vote
• Widget customization: colors, trigger button position, custom fields
• Linear integration (two-way sync: feature request → Linear issue → status update)
• Slack notifications for new posts, high-vote milestones, status changes
• Custom domain support for public boards/roadmaps
• AI weekly digest email generation (cron job + AI)
• Stripe billing integration ($15/$29/$59 tiers)
• Landing page, documentation, and demo board

The Business Case

A realistic look at the economics, who pays, how much, and what credible growth scenarios look like from launch through $10K MRR and beyond.

💰 Revenue Model & Pricing

Pricing Strategy: Simple Flat Tiers (No Per-User Traps)

The #1 frustration with Canny is per-tracked-user pricing that escalates unpredictably. FeedbackPilot uses flat monthly pricing:

Plan	Price	Tracked Users	Features
Free	$0	100 users	1 board, public roadmap, basic widget, 50 AI actions/mo
Starter	$15/mo	1,000 users	3 boards, changelog, full widget, 200 AI actions/mo, email digest
Growth	$29/mo	5,000 users	Unlimited boards, AI duplicate detection, custom domain, Linear sync, 500 AI actions/mo
Team	$59/mo	Unlimited users	Everything + team seats (5), Slack integration, webhooks, API access, unlimited AI, priority support

Why this works:

• Free tier: Generous enough for very early-stage products. Gets founders hooked on the tool before they need to pay. The 100 tracked users covers the first beta users.
• Starter at $15/mo: 5x cheaper than Canny Starter ($79/mo) with comparable core features. A founder making $1,000 MRR can justify $15/month for organized feedback. 6.7x cheaper than Canny.
• Growth at $29/mo: All the features most founders need. Canny charges $359/month for similar functionality (AI, integrations, unlimited roadmaps). 12.4x cheaper than Canny Growth.
• Team at $59/mo: Full feature set for small teams. Still 79% cheaper than Canny Growth ($359/mo) and a fraction of UserVoice ($699/mo).

Annual discount: 20% off annual billing ($12, $23.20, $47.20/mo respectively).

📊 Revenue Potential & Analysis

From initial market sizing through unit economics to scenario-based projections, here's the full financial case for pursuing this opportunity.

Market Sizing (TAM/SAM/SOM)

TAM (Total Addressable Market): The product management software market reached $12.5 billion in 2024, growing at 12.4% CAGR (Allied Market Research). The feedback management and feature voting sub-segment represents approximately 6-8% of this market: TAM = $750M-1B/year.

SAM (Serviceable Addressable Market): Focusing on SaaS companies with under 10,000 users in English-speaking markets: approximately 300,000 active SaaS products on Stripe, plus 200,000+ on other platforms. Assuming 40% need dedicated feedback tools at $30/month average: SAM = $72M/year.

SOM (Serviceable Obtainable Market): In Year 1, targeting indie hackers and early-stage SaaS founders on Reddit, Indie Hackers, Twitter, and Product Hunt. Realistic reach: 30,000 potential customers. At a 2.5% conversion rate with $25 average MRR: SOM = $225K/year ($18.8K MRR) in Year 1, scaling to $750K/year ($62.5K MRR) by Year 2.

Unit Economics

Metric	Value
Average Revenue Per User (ARPU)	$25/mo (blended across plans)
Customer Acquisition Cost (CAC)	$20 (community + SEO driven)
Gross Margin	89% (low-compute CRUD operations + occasional AI calls)
Monthly Churn Rate	3% (feedback boards are sticky once populated with votes)
Customer Lifetime Value (LTV)	$742 (33.3 months × $25 ARPU × 89% margin)
LTV:CAC Ratio	37.1x (exceptional for SaaS tooling)

Cost breakdown per customer per month:

• Database & API hosting (Supabase/Vercel): ~$1.20/customer
• AI inference (categorization, dedup, summaries): ~$0.40/customer
• Widget CDN (Cloudflare): ~$0.05/customer
• Email delivery (weekly digests): ~$0.05/customer
• Storage (images, attachments): ~$0.15/customer
• Total COGS: ~$1.85/customer → $23.15 gross profit per customer

Revenue Build-Up (Base Scenario)

Month	Customers	MRR	Commentary
1-2	50	$1,250	Free tier users converting, Reddit community seeding
3-4	150	$3,750	Product Hunt launch, "Canny alternative" SEO content
5-6	300	$7,500	Word-of-mouth among SaaS founders, integrations (Linear, GitHub)
7-9	450	$11,250	Referral program, partnerships with SaaS boilerplate tools
10-12	650	$16,250	Feature expansion, approaching profitability at scale
13-18	1,200	$30,000	Market expansion, team plan adoption
19-24	2,000	$50,000	Category leader in affordable feedback tools

Scenario Analysis

Conservative Scenario (450 customers @ $20 avg MRR in 12 months):

• MRR: $9,000
• ARR: $108,000
• Monthly costs: ~$1,500 (infrastructure + AI)
• Monthly profit: ~$7,500
• Assumption: Slow organic growth, competitive pressure from UserJot/ProductLift

Base Scenario (800 customers @ $25 avg MRR in 12 months):

• MRR: $20,000
• ARR: $240,000
• Monthly costs: ~$2,500
• Monthly profit: ~$17,500
• Assumption: Successful community launches, good SEO, moderate word-of-mouth

Optimistic Scenario (1,500 customers @ $33 avg MRR in 12 months):

• MRR: $49,500
• ARR: $594,000
• Monthly costs: ~$4,000
• Monthly profit: ~$45,500
• Assumption: Viral growth from "vibe coder" community, strong referral program, partnership with SaaS boilerplates

How to Build It

A complete technical blueprint: database schema, stack recommendations, and AI builder prompts to go from idea to working MVP as fast as possible.

🗄️ Database & Schema

-- Workspace/product owners
CREATE TABLE workspaces (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    name TEXT NOT NULL,
    slug TEXT UNIQUE NOT NULL,
    owner_email TEXT NOT NULL,
    plan TEXT NOT NULL DEFAULT 'free' CHECK (plan IN ('free', 'starter', 'growth', 'team')),
    tracked_user_limit INTEGER DEFAULT 100,
    logo_url TEXT,
    brand_color TEXT DEFAULT '#6366F1',
    custom_domain TEXT,
    stripe_customer_id TEXT,
    stripe_subscription_id TEXT,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Team members (for team plan)
CREATE TABLE workspace_members (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id UUID NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
    user_email TEXT NOT NULL,
    role TEXT NOT NULL DEFAULT 'member' CHECK (role IN ('owner', 'admin', 'member')),
    invited_at TIMESTAMPTZ DEFAULT NOW(),
    accepted_at TIMESTAMPTZ,
    UNIQUE(workspace_id, user_email)
);

-- Feedback boards (Feature Requests, Bug Reports, Ideas, etc.)
CREATE TABLE boards (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id UUID NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
    name TEXT NOT NULL,
    slug TEXT NOT NULL,
    description TEXT,
    is_public BOOLEAN DEFAULT true,
    allow_guest_voting BOOLEAN DEFAULT true,
    sort_default TEXT DEFAULT 'votes' CHECK (sort_default IN ('votes', 'newest', 'trending')),
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW(),
    UNIQUE(workspace_id, slug)
);

-- Feedback posts (feature requests, bugs, ideas)
CREATE TABLE posts (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    board_id UUID NOT NULL REFERENCES boards(id) ON DELETE CASCADE,
    workspace_id UUID NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
    author_id UUID REFERENCES tracked_users(id) ON DELETE SET NULL,
    title TEXT NOT NULL,
    body TEXT,
    status TEXT NOT NULL DEFAULT 'open' CHECK (status IN ('open', 'under_review', 'planned', 'in_progress', 'complete', 'declined')),
    category TEXT,
    tags TEXT[] DEFAULT '{}',
    vote_count INTEGER DEFAULT 0,
    comment_count INTEGER DEFAULT 0,
    is_pinned BOOLEAN DEFAULT false,
    ai_category TEXT,
    ai_duplicate_of UUID REFERENCES posts(id) ON DELETE SET NULL,
    merged_into UUID REFERENCES posts(id) ON DELETE SET NULL,
    priority_score NUMERIC DEFAULT 0,
    admin_notes TEXT,
    decline_reason TEXT,
    external_id TEXT,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Tracked users (end users who submit feedback and vote)
CREATE TABLE tracked_users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id UUID NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
    external_user_id TEXT,
    email TEXT,
    name TEXT,
    avatar_url TEXT,
    properties JSONB DEFAULT '{}',
    first_seen_at TIMESTAMPTZ DEFAULT NOW(),
    last_seen_at TIMESTAMPTZ DEFAULT NOW(),
    created_at TIMESTAMPTZ DEFAULT NOW(),
    UNIQUE(workspace_id, external_user_id)
);

-- Votes on posts
CREATE TABLE votes (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    post_id UUID NOT NULL REFERENCES posts(id) ON DELETE CASCADE,
    user_id UUID REFERENCES tracked_users(id) ON DELETE SET NULL,
    guest_fingerprint TEXT,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    UNIQUE(post_id, user_id)
);

-- Comments on posts
CREATE TABLE comments (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    post_id UUID NOT NULL REFERENCES posts(id) ON DELETE CASCADE,
    author_id UUID REFERENCES tracked_users(id) ON DELETE SET NULL,
    admin_author_email TEXT,
    body TEXT NOT NULL,
    is_internal BOOLEAN DEFAULT false,
    is_admin_reply BOOLEAN DEFAULT false,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Roadmap items (linked to posts)
CREATE TABLE roadmap_items (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id UUID NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
    post_id UUID REFERENCES posts(id) ON DELETE SET NULL,
    title TEXT NOT NULL,
    description TEXT,
    status TEXT NOT NULL DEFAULT 'planned' CHECK (status IN ('planned', 'in_progress', 'complete', 'cancelled')),
    display_order INTEGER DEFAULT 0,
    target_date DATE,
    is_visible BOOLEAN DEFAULT true,
    completed_at TIMESTAMPTZ,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Changelog entries (auto-generated or manual)
CREATE TABLE changelog_entries (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id UUID NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
    roadmap_item_id UUID REFERENCES roadmap_items(id) ON DELETE SET NULL,
    title TEXT NOT NULL,
    body TEXT NOT NULL,
    tags TEXT[] DEFAULT '{}',
    is_published BOOLEAN DEFAULT false,
    ai_generated BOOLEAN DEFAULT false,
    published_at TIMESTAMPTZ,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- AI weekly digest summaries
CREATE TABLE ai_digests (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id UUID NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
    period_start DATE NOT NULL,
    period_end DATE NOT NULL,
    summary_text TEXT NOT NULL,
    top_themes JSONB,
    sentiment_analysis JSONB,
    recommended_priorities JSONB,
    sent_at TIMESTAMPTZ,
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Widget configuration
CREATE TABLE widget_configs (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    workspace_id UUID NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
    board_id UUID REFERENCES boards(id) ON DELETE SET NULL,
    position TEXT DEFAULT 'bottom-right' CHECK (position IN ('bottom-right', 'bottom-left', 'top-right', 'top-left')),
    trigger_text TEXT DEFAULT 'Feedback',
    trigger_color TEXT DEFAULT '#6366F1',
    allow_attachments BOOLEAN DEFAULT false,
    custom_fields JSONB DEFAULT '[]',
    is_active BOOLEAN DEFAULT true,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- Indexes for performance
CREATE INDEX idx_boards_workspace ON boards(workspace_id);
CREATE INDEX idx_posts_board ON posts(board_id);
CREATE INDEX idx_posts_workspace ON posts(workspace_id);
CREATE INDEX idx_posts_status ON posts(status);
CREATE INDEX idx_posts_votes ON posts(vote_count DESC);
CREATE INDEX idx_votes_post ON votes(post_id);
CREATE INDEX idx_votes_user ON votes(user_id);
CREATE INDEX idx_comments_post ON comments(post_id);
CREATE INDEX idx_tracked_users_workspace ON tracked_users(workspace_id);
CREATE INDEX idx_roadmap_workspace ON roadmap_items(workspace_id);
CREATE INDEX idx_roadmap_status ON roadmap_items(status);
CREATE INDEX idx_changelog_workspace ON changelog_entries(workspace_id);
CREATE INDEX idx_changelog_published ON changelog_entries(published_at DESC) WHERE is_published = true;
CREATE INDEX idx_ai_digests_workspace ON ai_digests(workspace_id);
CREATE INDEX idx_widget_configs_workspace ON widget_configs(workspace_id);

⚡ Tech Stack

Frontend & Dashboard:

• Next.js+ with App Router, dashboard + public board/roadmap pages
• Tailwind CSS: consistent, rapid UI development
• DnD Kit: drag-and-drop for roadmap kanban board
• Recharts: analytics charts (vote trends, category breakdown)

Embeddable Widget:

• Vanilla JavaScript: zero dependencies, <10KB gzipped
• Shadow DOM: CSS isolation from host app
• CDN-hosted (Cloudflare), global low-latency delivery

Backend:

• Next.js API Routes: all API endpoints
• Supabase: PostgreSQL + Auth + Realtime (for live vote updates)
• an AI language model: categorization, duplicate detection, changelog generation, weekly digests

Infrastructure:

• Vercel: hosting ($20/mo Pro)
• Supabase: database + auth ($25/mo Pro)
• Cloudflare: widget CDN ($0-5/mo)
• AI API: AI features (~$10-20/mo)
• Total: ~$60-70/month

🤖 AI Builder Prompts

Frontend/UI

Build an AI-powered feature voting and public roadmap SaaS called FeedbackPilot. The system has three components:

1. DASHBOARD (Next.js + Supabase):
   - Auth via Supabase
   - Workspace management with custom branding
   - Feedback board CRUD: create boards, manage posts, moderate
   - Post management: status changes (open → planned → in_progress → complete → declined)
   - Voting system: upvotes per user/guest, vote count aggregation
   - Comments with admin replies and internal notes
   - Public roadmap page: kanban view with drag-and-drop
   - Changelog feed: auto-generated + manual entries
   - AI features: duplicate detection, categorization, weekly digest
   - Stripe billing integration

2. PUBLIC PAGES (Next.js):
   - /[workspace-slug]/board/[board-slug], public feedback board with voting
   - /[workspace-slug]/roadmap, public roadmap kanban
   - /[workspace-slug]/changelog, public changelog feed
   - Custom domain support via CNAME
   - SEO-optimized, fast-loading, branded

3. EMBEDDABLE WIDGET (Vanilla JS):
   - <script src="https://cdn.feedbackpilot.com/widget.js" data-key="WS_KEY"></script>
   - Floating trigger button → opens feedback form overlay
   - Submit new request + vote on existing ones
   - Shadow DOM for CSS isolation
   - <10KB gzipped

Tech stack: Next.js, Supabase, Stripe, Tailwind CSS, AI.
Start with database schema, then voting logic, then public pages, then widget.

Backend/API

I'm building the AI duplicate detection feature for my feature voting SaaS. When a user submits a new feature request, I need to check if a similar request already exists.

Input: New post title + body text
Database: All existing posts for this workspace (title, body, vote_count, status)

Write the implementation using an embeddings API:
1. Generate an embedding for the new post (title + body combined)
2. Compare against stored embeddings for existing posts using cosine similarity
3. Return posts with similarity score > 0.82 as potential duplicates
4. Also write a prompt for an AI language model to generate a human-readable merge suggestion: "This looks similar to 'Add dark mode' (47 votes). Merge?"

For the AI categorization feature:
Input: Post title + body text
Output: One category from predefined list + confidence score
Categories: UI/UX, Performance, New Feature, Integration, Bug Fix, Documentation, Pricing, Mobile, API, Other

Write the system prompt that consistently categorizes feedback into these buckets.

Also write the changelog generation prompt:
Input: Feature title, description, board name, vote count
Output: Professional changelog entry (150-250 words) with title, summary, and "why we built this" section.

Database

Create a feature voting and roadmap tool using no-code platforms:

1. Softr or Bubble for the dashboard and public board pages
2. Airtable as the database for workspaces, boards, posts, votes, roadmap items
3. Make.com for automation:
   - New post submitted → AI API for categorization and duplicate check → Update Airtable
   - Post status changed to "Complete" → AI generates changelog → Create changelog entry
   - Weekly trigger → Aggregate vote data → AI generates digest → Send email via SendGrid
4. Tally.so for the embedded feedback form (simpler than building a custom widget)
5. Stripe for subscription billing

Airtable schema:
- Workspaces table: name, slug, plan, branding
- Boards table: linked to workspace, name, is_public
- Posts table: linked to board, title, body, status, vote_count, ai_category
- Votes table: linked to post + user
- Roadmap table: linked to post, status column, display order
- Changelog table: linked to roadmap item, title, body, published flag

The public board in Softr should show:
- List of posts sorted by votes
- Upvote button per post
- Status badges (Open, Planned, In Progress, Complete)
- Submit new request form

Start with Airtable schema, then Softr pages, then Make.com automations.

Deployment/Auth

Generate a modern dashboard and public pages for a feature voting SaaS called FeedbackPilot using Next.js and Tailwind CSS. Primary color: Indigo (#6366F1).

Pages needed:

1. Admin Dashboard: Sidebar with nav (Boards, Roadmap, Changelog, Analytics, Settings). Main area shows: total posts, total votes this month, trending requests (top 5 by recent velocity), and AI insight card ("3 duplicate requests detected this week"). Recent activity feed.

2. Board Management: List of feedback boards with post count, last activity. Click into a board to see posts in a table: Title, Votes (with up arrow icon), Status (colored badge), Category (tag), Date. Bulk actions: merge, change status. Filter by status and category. Search bar.

3. Post Detail: Left side: title, body, vote count with big upvote button, author info, created date. Right side: status dropdown, category tag, admin notes textarea, AI-detected duplicates panel ("Similar: Dark mode request, 47 votes, Merge?"). Comments thread below.

4. Public Roadmap: Clean kanban board with 3 columns (Planned, In Progress, Complete). Each card shows: title, vote count, category tag. Responsive. Company logo and branding at top. "Powered by FeedbackPilot" footer.

5. Public Board: List of feature requests sorted by votes. Each item: title, body preview (2 lines), vote button with count, status badge, comment count, time ago. "Submit Request" button opens a modal form. Category filter tabs at top.

6. Changelog Page: Timeline view with entries showing: date, title, body (markdown), tags (New Feature, Improvement, Bug Fix). Clean, minimal design.

Design: Indigo (#6366F1) primary, white backgrounds, subtle gray borders, Inter font, Lucide icons. The public pages should feel polished enough that founders are proud to share them.

How to Sell It

Distribution is half the battle. Here's the go-to-market playbook: channels, messaging, and the key metrics that signal you're finding product-market fit.

📣 Go-to-Market Playbook

Phase 1: Community Seeding (Weeks 1-4)

1. Reddit Community Marketing: r/SaaS, r/microsaas, r/indiehackers, r/ProductManagement, and r/webdev are where our exact customers live. Every "what feedback tool do you use?" thread is an opportunity. Write a genuine post: "How I replaced Canny with a $15/month alternative for my SaaS." Share the journey authentically.

2. Indie Hackers Build-in-Public: Document the building process, share revenue numbers, and engage the community. IH loves SaaS tooling products, especially ones that solve their own pain points.

3. Product Hunt Launch: "The affordable Canny alternative with AI" is instantly understood. Demo video: install widget → user submits request → AI detects duplicate → show on roadmap → auto-generate changelog. The complete loop in 60 seconds.

4. Free Tier as Growth Engine: The generous free plan (100 tracked users, 1 board) lets founders try the tool with zero risk. Conversion trigger: they hit the board/user limit as their product grows.

Phase 2: SEO & Content (Months 2-4)

1. "Canny Alternative" SEO: Create comparison pages, "FeedbackPilot vs Canny", "FeedbackPilot vs UserVoice", "Best Feature Voting Tools 2026." These capture high-intent search traffic from founders actively evaluating tools.

2. Educational Content: "How to Build a Public Roadmap That Users Actually Check", "Feature Prioritization Framework for Indie Hackers", "Why Your SaaS Needs a Changelog." Establish authority in product feedback space.

3. Free Roadmap Template: Offer a free public roadmap template (Notion + FeedbackPilot integration). Capture email leads and nurture to paid.

Phase 3: Partnerships & Scale (Months 4-8)

1. SaaS Boilerplate Partnerships: Partner with ShipFast, Gravity, Makerkit, and other SaaS starter templates to include FeedbackPilot as the default feedback tool. Capture founders at the moment of product creation.

2. Integration Ecosystem: Build tight integrations with Linear, GitHub Issues, Slack, Discord, and Notion. Each integration creates distribution through partner directories.

3. Referral Program: "Give a founder friend 1 month free, get 1 month free." SaaS founders recommend tools to each other constantly, leverage this.

4. "Powered by FeedbackPilot" Viral Loop: The free plan includes subtle "Powered by FeedbackPilot" branding on public boards and roadmaps. Every public board becomes a marketing channel.

📈 Success Metrics & KPIs

Product Metrics:

Metric	Target (Month 3)	Target (Month 12)
Workspaces Created	500	3,000
Active Boards	200	1,500
Posts Submitted (Total)	5,000	80,000
Votes Cast (Total)	15,000	300,000
Public Roadmaps Live	100	800
Widget Installations	80	600

Business Metrics:

Metric	Target (Month 6)	Target (Month 12)
MRR	$5,000	$16,250
Paying Customers	200	650
Free → Paid Conversion	6%	12%
Monthly Churn Rate	< 5%	< 3%
CAC	< $30	< $20
LTV:CAC Ratio	> 15x	> 30x

Risks & Mitigations

No opportunity is without risk. Here's an honest assessment of what could go wrong, and specific strategies to reduce those risks before they become fatal.

⚠️ Key Risks & Mitigations

Risk 1: Crowded Market with Many Small Competitors

• Impact: UserJot, ProductLift, Nolt, Featurebase, Sleekplan all compete in the affordable segment
• Mitigation: AI differentiation is genuine, auto-categorization, duplicate detection, and changelog generation create a fundamentally better experience. None of the budget competitors offer meaningful AI features today. Focus on the "AI-first feedback tool" positioning. Also: the market is large enough for multiple winners at different price points.
• Likelihood: High
• Severity: Medium (market is growing fast enough)

Risk 2: Canny Adds a Cheaper Tier

• Impact: Canny could launch a $29/month plan to compete with budget alternatives
• Mitigation: Canny has moved consistently upmarket (from $50 → $79 → now $79/starter, $359/growth). Their cost structure (50+ employees, $4M+ raised) makes it economically irrational to serve the $15/month segment. Even if they add a cheap tier, it will be severely limited. Counter-positioning protects us.
• Likelihood: Low (Canny is going upmarket)
• Severity: Medium

Risk 3: Low Switching Costs

• Impact: Users can export their feature requests and move to another tool easily
• Mitigation: Build switching costs through data accumulation (months of votes, comments, user data), AI improvements (the system gets smarter about categorization over time), and public URL lock-in (users share roadmap/board URLs that would break on migration). Also, feedback tools are "set and forget", once working, founders rarely switch.
• Likelihood: Medium
• Severity: Low

Risk 4: AI Features Don't Differentiate Enough

• Impact: Users might not value AI categorization/dedup enough to choose FeedbackPilot over simpler, cheaper alternatives
• Mitigation: AI saves measurable time, duplicate detection alone removes 30-40% of manual triage work. The weekly AI digest replaces hours of manual feedback review. Position AI not as a gimmick but as a time-saver for busy founders who can't spend hours managing feedback.
• Likelihood: Medium
• Severity: Low-Medium

Risk 5: Free Tier Attracts Non-Converting Users

• Impact: Large free user base with low conversion drains resources without revenue
• Mitigation: Free tier is deliberately limited (100 tracked users, 1 board, 50 AI actions). The limits naturally trigger upgrades as products grow. Focus support resources on paid customers. Use free tier as social proof ("5,000+ SaaS products use FeedbackPilot").
• Likelihood: Medium
• Severity: Low

Wrap-Up

The bottom line: the key takeaways, the go/no-go verdict, and the exact first steps to take if you decide to pursue this gap.

🔑 Key Takeaways

1. Clear Pricing Gap: Canny charges $79-359/month, UserVoice $699+/month, but indie SaaS founders need the same core functionality at $15-39/month.

2. Validated Demand: Multiple indie developers have independently built Canny alternatives, and one posted publicly that they're "making money", proving the market sustains profitable indie products.

3. AI Differentiation: Auto-categorization, duplicate detection, changelog generation, and weekly digests create genuine productivity gains that justify choosing FeedbackPilot over free or bare-bones alternatives.

4. Exceptional Unit Economics: 89% gross margin, 37x LTV:CAC ratio, and minimal infrastructure costs. Feature boards are simple CRUD, the cheapest type of SaaS to operate.

5. Natural Viral Loop: "Powered by FeedbackPilot" on free-tier public boards and roadmaps creates organic distribution. Every customer's public roadmap is a marketing channel.

6. Low Technical Risk: Feedback boards, voting, kanban roadmaps, and changelog feeds are basic CRUD patterns with a voting layer. A solo developer can ship a polished MVP in 2-3 weeks using AI coding tools.

7. Growth Aligned with Customer Growth: As customers' SaaS products grow, they hit tracked user limits and upgrade naturally. Revenue grows with your customers' success.

📚 Sources & References

1. UserJot: Canny Pricing 2026 Analysis, Canny Starter $79/mo, Growth $359/mo, PM integrations paywalled
2. UserJot: Top 9 ProductBoard Alternatives 2026, ProductBoard $19-59/maker, Aha! $35K+/year
3. ProductLift: Top 12 UserVoice Alternatives 2026, UserVoice $699/mo minimum, Featurebase at $49/mo
4. ProductLift: Sleekplan Alternatives 2026, UserVoice $1,333/mo, ProductBoard per-maker pricing
5. ProductLift: UserJot Alternatives 2026, Market landscape with pricing data
6. ProductLift: FeatureUpvote Alternatives 2026, Frill $25/mo, ProductBoard $25+/maker
7. Savio: 11+ Feature Voting Tools, UserVoice $699-1,349/mo for basic features
8. Frill: How to Offer Feature Voting, Sleekplan feedback tool overview, Frill $79/mo Pro
9. Supahub: Top 14 Feature Voting Tools for SaaS, Feature Upvote and comprehensive tool comparison
10. SaaSworthy: Canny Reviews & Pricing Feb 2026, Canny starts at $79, features overview
11. RightFeature: Best Changelog Tools 2026, Canny Pro $661/mo (1K tracked users), Business $10K+/yr
12. TheCXLead: 30 Best Feedback Management Tools 2026, Comprehensive landscape overview
13. CPOClub: 22 Best AI Product Roadmap Software 2026, AI roadmap tool comparison
14. RightFeature: Feature Prioritization Matrix Guide 2026, Real-time voting integration benefits
15. Kanbanchi: Best Product Roadmap Tools 2026, Team-focused roadmap tool comparison
16. r/SaaS: Feature Request and Voting Tools, "Canny gets expensive fast once you grow"
17. r/SaaS: Customer Feedback Tool Discussion, "Most feedback tools charge way too much for basic stuff"
18. r/SaaS: Canny Alternative Built, "Affordable to early-stage SaaS companies"
19. r/SideProject: Canny Competitor Making Money, Validated profitability of budget feedback tools
20. r/webdev: Canny.io Alternatives, "More affordable than Canny"