Feature Requests: Template, Real Examples, and Replies

Shayan, FounderUpdated 19 min read

A row of handwritten order tickets pegged to a wire above a restaurant kitchen pass, with two cooks in white plating food behind the counter, a waiter in a bow tie beside a stack of plates, and a man in an apron seen from behind.

A feature request is just a user asking your product to do something it doesn't do yet.

On paper, that sounds simple. In practice, when a customer hits a wall in your app, they don't stop to write a product spec. They picture the fastest button or setting that would unblock them right now and ask for that. If they can't find a report, they ask for a CSV export. If notifications are noisy, they ask for a mute toggle.

The reason behind the ask is almost always more useful than the ask itself. Take a request filed on Cal.com's GitHub tracker in October 2026 asking for a "spam" booking status. Adding a whole new status to a booking system is a big change. But look at how the user explained the problem:

The API reports only accepted, pending, rejected, cancelled and awaiting_host. Unconfirmed bookings can't be rejected once their time has passed, so bot bookings stay "pending" in reporting forever.

Now the problem makes sense. The user doesn't really care about having a "spam" badge. They just want dead bot bookings out of their reports. Once you know that, you can solve it in a few simpler ways without touching the core booking statuses.

I spend a lot of time looking at how software teams collect and reply to feedback, since we build UserJot. For this guide, I went through the issue forms, public boards, and staff replies of two dozen products, including VS Code, Obsidian, Ghost, and Jira, to see how real teams handle feature requests from the first message to the day the feature ships.

What is a feature request?

A feature request is a user asking for a capability your product doesn't have. It can show up anywhere customers talk to you: a support chat, a forum post, a GitHub issue, a vote on a feedback board, or a quick reply to an onboarding email.

The teams that get usable requests structure their intake so the user has to explain what they were trying to do first.

Node.js keeps its GitHub feature request form to three questions:

  1. What is the problem this feature will solve?
  2. What is the feature you are proposing to solve the problem?
  3. What alternatives have you considered?

Obsidian's forum template starts the same way: "What's your use case for this feature? In other words, what are you trying to accomplish when you realize you need this feature?" And Grafana's contributor guide gives "Dashboard export doesn't work well with variables." as an example of a weak request, telling writers to avoid jumping straight to a solution or writing vague lines like "it would be nice if..."

Feature request vs. bug report

A bug report says something your product already promises is broken. A feature request asks for a new promise.

When both land in the same queue, one ruins the other. Engineers trying to fix real bugs have to wade through open-ended debates about product direction, or feature ideas get treated like tickets that have to be closed by Friday. Bugs belong in your issue tracker so engineers can reproduce and fix them. Feature requests need a place where people can vote, add context, and group similar ideas before anyone writes code.

Expo enforces this split aggressively. Its GitHub issue form for feature requests exists only to turn people away. It has one required dropdown:

Do you understand that any feature requests opened in the core Expo repository will be closed?

The only option in the dropdown is "Yes," along with a link to Expo's feedback board. Home Assistant draws a similar line for integrations: if someone asks for a third-party integration to be built into core, and a community integration already exists through HACS, they treat the request as already solved.

What a good feature request contains

A long intake form kills submissions. If someone has to fill out ten fields just to tell you a table is hard to sort, they'll close the tab and complain to a coworker instead.

If you look at the feature request forms used by projects like Node.js, Obsidian, Grafana, and Flutter, most of them stick to a variation of the same five questions:

  1. The problem or use case. What are you trying to do, and where do you get stuck? Grafana asks for "a description of the problem the feature is trying to solve," and Home Assistant calls this field "Current limitations."
  2. The proposed solution. What do you want the product to do? Flutter's form asks users to "Briefly but precisely describe what you would like Flutter to be able to do. Consider attaching something showing what you are imagining: images, videos, code samples".
  3. Alternatives or workarounds tried. How are you dealing with this today? Node.js, Obsidian, Next.js, and Flutter all ask for this. If someone built a brittle three-step spreadsheet script to work around a missing feature, you know the pain is real. If their answer is "nothing, I just thought of it," you know it can wait.
  4. Who it affects, and the scope. Grafana asks "Who is this feature for?" and Next.js asks for "Goals" and "Non-Goals." A problem that blocks a customer's end users is very different from a minor annoyance for one admin.
  5. A check for duplicates first. VS Code, Obsidian, and Flutter all remind people to search existing requests before posting. As Obsidian's template puts it: "If your request is very similar to an existing one, like it (❤️) and make a meaningful comment, rather than creating a new thread."

There is one field that almost every downloadable template on the web forgets: how to reach the person who asked. Unless requests come through an authenticated feedback board or GitHub where the user's account is attached automatically, an anonymous form submission leaves you with no way to ask a follow-up question or tell the customer when you build their idea.

Feature request template

If you're setting up a form, a doc, or an email template to collect requests from customers, these six fields cover everything your team needs without feeling like homework.

# Title: one line describing what you want to do
 
## Problem
 
What are you trying to do, and what stops you today? Describe the
situation, not the feature.
 
## Proposed solution
 
What would you like the product to do? A screenshot, sketch, or
example from another tool helps.
 
## What you do instead today
 
Your current workaround, if you have one, and how much time or
trouble it costs you.
 
## Who this is for
 
Just you, your team, or your own customers.
 
## How to reach you
 
Email or account, so we can ask a quick question or let you know
when it ships.

A GitHub issue form for feature requests

If you collect feature requests in a GitHub repository, use a YAML issue form in .github/ISSUE_TEMPLATE/ rather than a plain Markdown file. Markdown templates cannot make fields required, whereas YAML forms turn each question into a required input. This one is modeled on Node's three questions with a duplicate check at the top:

name: Feature request
description: Suggest something the project does not do yet
labels: ['feature request']
body:
  - type: checkboxes
    attributes:
      label: Before you post
      options:
        - label: I searched existing issues and discussions for this request
          required: true
  - type: textarea
    id: problem
    attributes:
      label: What is the problem this feature will solve?
    validations:
      required: true
  - type: textarea
    id: proposal
    attributes:
      label: What is the feature you are proposing to solve the problem?
    validations:
      required: true
  - type: textarea
    id: alternatives
    attributes:
      label: What alternatives have you considered?

Feature request document

Sometimes people say "feature request document" when they mean the internal one-page write-up a product team puts together once a request has enough traction to seriously consider building.

Open-source projects have heavy versions of this, like Rust's RFC template or Kubernetes's Enhancement Proposals, which include test plans and graduation criteria. For a SaaS team, a single page linked to the original request on your feedback board is plenty:

# Feature request: <name>
 
## Problem
 
In the customers' own words. Link the threads on the feedback board.
 
## Evidence
 
How many people asked, how many voted, which customers, and which
support conversations it came up in.
 
## Proposal
 
What we would build, in one short paragraph.
 
## Out of scope
 
What this version will not cover, so the scope doesn't creep during
review.
 
## Open questions
 
Anything we still need to figure out before building.
 
## Decision
 
Build, later, or no, with the reason and the date.

Where feature requests come from, and where to keep them

Feature requests show up everywhere: support chats, onboarding email replies, sales calls, community forums, and bug reports that turn out not to be bugs.

What usually happens on a young team is that someone pastes a screenshot of a customer email into a #product-feedback Slack channel, two people react with a fire emoji, and three days later it scrolls out of view forever. Then whichever customer yelled loudest on yesterday's sales call gets their feature built next.

Most software teams fix this by funneling requests into one place where users can browse existing ideas and vote:

  • Dedicated feedback boards are the easiest path for SaaS teams because customers don't need a GitHub or forum account just to vote. Plausible, Webflow, and Expo all run public boards. If you're choosing one, I compared ten feature request tools on price and where each one's limits start.
  • GitHub Issues and Discussions work well when your users are developers who already live on GitHub. Cal.com and PostHog track requests as Issues with thumbs-up reactions, while Supabase, Tailwind, and Next.js use GitHub Discussions.
  • Community forums fit products with active user communities, like Obsidian and Ghost on Discourse, or Figma and Miro on Gainsight.
  • Private intake is the route for teams like Linear, Notion, and Todoist, which don't run a public board at all. Raycast collects requests through a Send Feedback command built right into the app.

Even when you have a public board, a lot of requests will still start in a support conversation or an email. Get every request onto that one list, in the customer's words, with a way to reach them later.

Two house rules save a lot of cleanup:

  1. One request per post. When a user submits five ideas in one message, nobody knows which idea the upvotes are for, and you can't mark half a post as shipped. Strapi puts this rule right on its board: "One post = one request. If you have several ideas, please split them into separate posts."
  2. Catch duplicates early. On Jira Cloud's public tracker, 1,893 feature suggestions have been closed as duplicates. Prettier's issue template asks users to add a thumbs-up reaction to existing issues instead of opening new ones. A feedback board that searches existing posts as the user types prevents most duplicates automatically, and lets you merge the rest without losing anyone's votes.

How teams decide what to build

Nobody keeps bad ideas on their roadmap. Filtering out the obvious junk takes five seconds. The hard part of managing feature requests is that once your product gets any traction, you'll be flooded with genuinely good ideas from paying customers, and you still have to say no to almost all of them.

Obsidian's forum moderators note that they have "thousands of feature requests, each as valid for at least one user as the last." Steph Ango, who helps make Obsidian, added some context on Hacker News in June 2026: their team is only seven people, and when he asked the community what features they should remove from the app, he wrote, "I mostly got feature requests."

Every team hears the same arguments to sneak a feature onto the roadmap: "it'll only take an afternoon," "this customer is about to churn," "competitor X already has it," or "we can just make it an optional setting." Chasing feature parity on every rival checkbox or giving in to "just make it a setting" fifty times turns your preferences page into an airplane cockpit, inviting feature creep while every new feature after it takes twice as long to test. As open-source maintainer Jeff Geerling put it: "will this new code/feature make the project easier or harder to maintain?"

Even companies with huge engineering teams ship a much smaller share of requests than users think. One of the only teams to publish a real number is UserVoice, which reported that out of 1,724 requests on its own portal, 382 shipped, a 22.2% delivery rate. On Atlassian's public tracker for Jira Cloud, out of 28,060 suggestions, 2,346 have been closed as fixed or done.

Because you have to say no to most things, it helps to be upfront about how you decide. VS Code has the clearest public triage process I've seen. Every feature request gets checked against four questions in their wiki:

  1. Does the proposal match our general product direction?
  2. Can our team afford to implement the feature?
  3. Does it have any reasonable chance of being implemented in the next 24 months?
  4. Has the community at large expressed interest, measured as more than 20 upvotes?

If the answer to either of the first two questions is no, the team closes the issue as out of scope right away. If it passes, it moves into a "Backlog Candidates" milestone, and a bot posts the ground rules:

This feature request is now a candidate for our backlog. The community has 60 days to upvote the issue. If it receives 20 upvotes we will move it to our backlog. If not, we will close it. ...

Node.js draws an even firmer line in its contributor docs, telling users that "Feature requests are not a valuable source of input for the project," and asking them to open a pull request instead so the discussion can happen over real code.

If you're looking for scoring models like RICE, ICE, or MoSCoW, see our guide on how to prioritize feature requests. Whatever system you use, closing a request stings a little for the person who wrote it, and VS Code's wiki addresses that head-on:

If you are the author of a feature request you might not like that we close or don't plan to address your request. It might even feel like a slap in your face. We understand that.

Still, a clear no in 60 days is much kinder than the alternative. On Jira's tracker, a request for default system field values has been open since 2004 with 2,798 votes. Ghost's footnotes request has been marked planned since 2018. Spotify's highest-voted idea sits at a score of 26,457 with no status at all. Leaving a request in limbo for ten years doesn't spare anyone's feelings.

How to reply to a feature request

Every feature request eventually gets one of five answers: we're building it, tell us more, no, it already exists, or it shipped. You can grab copyable templates for each in how to respond to feature requests, and here is how real teams handle the first four in practice.

1. We will build it

The trap when accepting a request is getting excited and promising it before you've scoped the work.

In April 2018, a user on Ghost's forum asked for nested tags. A staff member replied: "Nice - we're definitely going to do this!" By November, he updated the thread to say it was in progress. Then in February 2019:

Sorry, yes - this actually ran into a few technical challenges and got put on pause at the end of last year. Will hopefully be able to circle back to it soon.

By 2020, frustrated users kept bumping the thread, and he closed it with: "Closing this topic now, because 'ya cant believe this isnt done yet' isn't useful to anyone." Every product team has stepped on this rake at least once. Compare that to how Obsidian's team confirms a feature on their forum:

Will be implemented in v1.11.x No ETAs.

Confirm the plan, skip the date unless the code is almost out the door, and post updates in the thread when you have them.

2. Tell us more

When a request is too vague to evaluate, ask a specific question that puts the ball back in the requester's court. On a request for a new configuration option in Ruff, a maintainer replied:

A good start would be a proposal for how the option would work (what is it named, what are the defaults, etc)

On Rust's internals forum, when someone proposed changing a compiler default for Linux debug sections, a project leader told them what evidence would actually sway the decision:

The best way to make a case for it would be to document which debuggers (or other tools relying on debug information) do and don't support it, in which versions, and thus which debuggers/tools we'd be breaking if we did this.

3. No

Saying no is uncomfortable, which is why so many teams hide behind "Good idea! I'll pass this along to the product team" or "We'll keep this on our radar." Customers know what that means. They'd much rather hear a straight no with the real reason and a workaround if one exists.

Sometimes a short link to your policy is enough. Prettier stopped accepting formatting options altogether and closes those issues with: "Sorry, we can't add option for this. https://prettier.io/docs/option-philosophy". When someone asked Ghost to open all links in a new window, a staff member replied "Absolutely not." and linked four articles on why opening new tabs hurts usability.

When a request is reasonable but still not happening, explain why and give the user a path forward. Here is how a Node.js maintainer closed a request to enable Corepack by default in March 2025:

Closing this issue as "not planned" as the Node.js TSC voted to stop distributing corepack in Node.js v25+ Corepack is not going away, and it will still be available on npm. You can still continue to use corepack by replacing the command corepack enable to npm i -g corepack. If you're a corepack user and want to contribute to its development, please refer https://github.com/nodejs/corepack/issues/681

Kubernetes did the same when declining "deny" rules for RBAC. The maintainer explained why it was rejected originally, citing "complexity, implications to upgrades, and unclear superuser/non-superuser interactions," and noted that anyone willing to work through those design questions could still open a formal Enhancement Proposal.

Even when a request has been sitting around for years, an honest close beats silence. When Atlassian moved a 17-year-old Jira request with 594 votes to "Not being considered," the product manager wrote: "There are still no plans to implement this suggestion at this stage. We know that transparency is important for you to plan how to best work with Jira, and will be transitioning this issue to 'Not being considered'. We understand our decision may be disappointing."

Saying no today doesn't mean you can never change your mind. VS Code closed a request for file nesting in July 2016 with "No plans at the moment. Closing until we reconsider this.", reopened it three months later with "This should have not been closed, reopening," and shipped it in January 2022 after 670 upvotes. And Flutter closed a 270-upvote drag-and-drop request by officially recommending a third-party package that solved the problem well.

4. This already exists or is a duplicate

Often the feature a user is asking for is already in the product, or already tracked on another thread.

When someone asked Ghost for subscribe forms, a moderator pointed out what was already there: "it's not clear to me what you are suggesting as an #ideas. The Ghost Memberships module already provides sign-up forms with a follow-up confirmation email."

When closing a duplicate, link the active thread and tell the user where things stand. A Flutter maintainer closed a duplicate GPU texture request the same day it was opened with:

Thanks for the detailed use case. This is tracked in #188776. The Impeller side landed in #188778, and the Flutter GPU API landed on master in #190036 ...

What about not replying at all?

Some teams simply don't have the bandwidth to reply to every thread, and the honest ones say so up front. Obsidian's forum rules state: "While the team does not respond to feature request, know that every one is read and considered". Apple's consumer feedback form says the same.

What frustrates users is a bot doing the ignoring for you. Grafana let a Google Analytics feature request with 117 upvotes sit open from 2016 until a stale bot closed it in 2024 "because it has not had any further activity in the last 30 days." Using a bot to explain clear rules, like VS Code's 60-day voting window, works fine. Having a bot close a popular seven-year-old request for "inactivity" when the team is the one not acting on it just burns goodwill.

Telling people when it ships

Most customers are used to their feedback disappearing into a void. When you email them six months later to say "hey, we built that thing you asked for," they remember it.

Almost every article about feedback tells you to "close the loop," yet very few show what that message looks like. Here are four real ones from public boards:

  • Spotify on a playlist mixing request with a score of 91: "Hey folks, Thanks for coming to the Spotify Idea Exchange and voting to make this happen. We're happy to announce that transitions on Mixed playlists are now available on desktop as well. ..."
  • Home Assistant on an MCP integration request: "This has been implemented in home-assistant/core#161547 and shipped with Home Assistant 2026.2. The MCP integration now connects using Streamable HTTP first and falls back to SSE when needed."
  • Ghost on a 2021 request for gift subscriptions: "Gift subscriptions are now an official feature in Ghost", followed by a link to the changelog post.
  • Atlassian in July 2026, on a Jira request from 2015 with 542 votes: "Formula Fields are now Generally Available in Jira Cloud! This has been one of the most requested features in Jira's history, and it's finally here. Thank you for your patience, your votes, and the feedback that shaped this feature."

Each one names the specific feature and the release, so the person getting the notification immediately recognizes what they asked for.

The catch is that teams often forget to send these updates until months later. When the fix ships on a Friday afternoon, going back through old threads to find the twelve people who asked for it is tedious, so it gets skipped. That Home Assistant reply went out roughly eight months after version 2026.2 shipped, during a cleanup sweep where a maintainer closed five shipped requests in one day. On another Ghost thread, a user asked on release day if the feature had shipped, and the official staff confirmation with the changelog card didn't land until seven weeks later.

A good shipped notification names the request, explains what's new in a sentence, links to the release notes or changelog entry, and reaches everyone who posted, voted, or commented on the idea.

Every status change emails everyone who asked.

On a UserJot board, every status change emails everyone who posted, voted, or commented on the request, and you can link your changelog post back to it. Free to start.

See feature request tracking

From the conversation to the shipped request

The reason those "it shipped" replies get forgotten is usually that the feedback lives in one tool, the support chat in a second, and the changelog in a third. We built UserJot so the request stays connected from the first conversation to the release note.

If you have Conversations turned on, currently in beta and free on every plan, a customer can ask for a feature right in your chat widget. Juno, our support agent, searches your public feedback board, shows them the matching request, and once they confirm, adds their vote or files a new request. If they post directly on the board or in the widget, it suggests similar requests as they type, and merging a duplicate moves the comments over while counting each voter once.

As you work through requests, moving one to Planned or In Progress puts it straight onto your public roadmap, and marking it Completed moves it to the Done column. Every status change emails everyone who posted, voted, or commented. When you're ready to announce the update, Juno can draft your changelog post in the editor from the requests you completed since your last post, and link those requests right underneath.

The UserJot requests page: every feature request in one list, with its votes, its status, and the people who asked.

How to handle feature requests

For a small SaaS team, staying on top of feature requests comes down to a few habits:

  1. Keep one list. Funnel every request onto a single board, one idea per post, in the customer's words, whether it started in support chat, GitHub, or a sales call.
  2. Capture the problem first. If a customer asks for a specific button or setting, ask what they're trying to accomplish before you log it.
  3. Publish how you decide. Whether it's VS Code's 20-upvote rule or a simple note on what fits your roadmap, write your policy down where users can see it.
  4. Keep statuses honest and close the loop. Don't leave requests sitting in limbo for years just to avoid saying no, and when you do ship a request, notify everyone who voted on it.

Frequently asked questions

What is a feature request?

A feature request is a customer asking for a capability your product doesn't have yet, along with the reason they need it. Good forms ask for the problem first, then the proposed solution, and then whatever workaround the person uses today.

What is the difference between a feature request and a bug report?

A bug report says something your product already offers is broken. A feature request asks for something new. Teams usually keep them separate so their issue tracker stays focused on bugs: Expo closes feature requests filed as GitHub issues and sends users to its feedback board instead.

What should a feature request include?

The problem you're trying to solve, your proposed solution, your current workaround, who the problem affects, and a way to reach you. Most forms ask for the problem and the proposed fix, while the contact field is the one standalone templates most often leave out.

How do you write a feature request?

Start with what you're trying to get done and what blocks you today, rather than jumping straight to the feature you want built. Search existing requests first so you can upvote an active thread instead of creating a duplicate, and attach a screenshot if your idea is visual.

What is a feature request document?

An internal one-page write-up a team creates when a request has enough demand to seriously evaluate. It summarizes the problem in the customers' words, the evidence from votes and support threads, the proposed build, what is out of scope, open questions, and the final decision.

How do you say no to a feature request?

State the decision plainly, give the real reason in a sentence or two, and share a workaround if one exists. When Node.js decided not to enable Corepack by default, the maintainer explained the committee vote that settled it and gave the npm command to use instead.

How many feature requests get built?

Fewer than most users expect. UserVoice reported shipping 382 out of 1,724 requests on its own feedback portal, or 22.2%. On Jira Cloud's public tracker, 2,346 out of 28,060 suggestions have been closed as fixed or done.

How long do feature requests wait?

It depends on the team's triage rules. VS Code gives candidate requests 60 days to gather 20 upvotes and only backlogs ideas it can realistically ship within 24 months. Without a cutoff like that, requests can sit for years: Jira's formula fields took eleven years to ship, and Ghost's footnotes request has been marked planned since 2018.

Should you reply to every feature request?

Not necessarily with a hand-written comment. Obsidian and Apple both tell users up front that they read every submission but can't reply individually. Updating a request's status on a board and automatically emailing the voters reaches everyone who cared without leaving threads silent.

What is an enhancement request?

Another name for a feature request. Kubernetes calls its template an "Enhancement Tracking Issue," and PostHog labels requests with both enhancement and feature.