The customer feedback loop: collect, prioritize, ship and follow up

A customer feedback loop is the cycle of collecting feedback, deciding what to do about it, shipping the change or giving an answer, and telling the customers who raised it. The loop is closed when the person who gave the feedback hears the outcome, including when the answer is no.

Most software teams collect plenty of feedback. Loops break later: between a request and a decision, between a decision and the work, and most often between a release and the customer who asked for it. This guide walks through the four stages, the two loops every software team runs, where loops break, what to measure and how Gleap supports each stage.

The four stages at a glance

Each stage answers one question. Collect: what are customers telling us, and in what context? Prioritize: what will we do about it? Ship: is the change built, reviewed and released? Follow up: did the people who asked hear the outcome?

Each stage hands an artifact to the next one. When a stage has no owner or no artifact, the loop stops there, usually without anyone noticing.

Two loops: individual follow-up and product change

Bain’s Net Promoter System describes two loops. The inner loop, described by Rob Markey in April 2015, routes feedback straight to the employees who served the customer and ends with a follow-up to that customer. The outer loop, described in June 2015, handles changes that individuals and teams cannot make on their own, such as policies, processes, pricing or product features, and tells the people who raised an issue how it was resolved. Markey, Reichheld and Dullweber had described the approach earlier in Closing the Customer Feedback Loop, Harvard Business Review, December 2009.

For a software company the split looks like this:

1. Inner loop. A customer reports a bug or asks a question. Support investigates, answers or gets it fixed, and replies on the same conversation.
2. Outer loop. Twenty customers ask for the same export format. Product weighs it against the roadmap, engineering builds it, and everyone who asked hears when it ships.

Both loops need the same foundation: one customer record, links between feedback and work, and someone responsible for telling the customer.

Stage 1: Collect feedback with its context

Collect feedback where customers already are: in the product, in support conversations, by email, on a public feature request board, in surveys and on sales calls. Then capture the context with each request:

1. Who asked: the customer, their company and their plan.
2. What they were doing: the page or screen, the steps, and for bugs the screenshot, the device and the logs.
3. What they want in their own words, before anyone rewrites it into a ticket title.
4. Whether it already exists: merge duplicates on arrival so demand adds up on one request instead of spreading over ten.

Some of the best feedback arrives in support conversations. Link it to a request right there rather than asking the customer to repeat it on a board.

Stage 2: Prioritize with evidence

Weigh each request against four inputs:

Give every request a decision state: planned, later, declined or waiting for information. “Later” without a reason turns into a graveyard. A decline with a reason closes the loop honestly and saves the customer from waiting.

Bugs take a faster path. Severity and the number of affected customers set the order, and an investigation settles whether the report is a bug at all.

Stage 3: Ship through normal review

Link the work to the feedback that started it: the ticket, the request, the pull request and the release. That link is what makes the follow-up possible later. Keep the changes small and reviewed. AI coding agents can prepare pull requests for approved work, and the review, the merge and the release stay with engineering.

A merge is not a release. Code can wait for a deployment window, stay behind a feature flag or sit in app store review. Plan the follow-up around the release, not the merge.

Stage 4: Follow up with the people who asked

Different people need different messages:

1. The customer who reported a bug gets a reply on the original conversation once the fix is live, with what changed and anything they need to do, such as updating the app.
2. The customers who voted for a request hear when it is planned, when it ships and when you decide against it.
3. Everyone else learns about it from the release notes or the changelog.
4. A customer who says it still happens gets the conversation reopened, and the loop starts again with better evidence.

Close the loop on a no as well. A clear decline with a reason builds more trust than a request that stays open for two years.

A closing message works when it is specific. For a shipped fix or feature, say what changed, what the customer needs to do, where to find it and thank them for the report. For a decline, give the reason, any workaround or alternative, and whether you would look at it again.

An example loop, stage by stage

Here is one illustrative request, followed through all four stages:

1. Collect. Three customers ask in chat for a PDF export of their monthly report. Support links each conversation to one feature request instead of creating three. Eleven more customers vote for it on the public board over the next month.
2. Prioritize. Product sees 14 votes, several from larger accounts, and an engineering estimate of a few days. It fits this quarter’s reporting goal, so the request moves to Planned and the voters hear that it is planned.
3. Ship. Engineering builds the export behind a feature flag. The pull request is reviewed and merged on Tuesday, and the flag is switched on for everyone on Thursday.
4. Follow up. On Thursday, not Tuesday, the voters get a message about the release with a link to the changelog entry, and the three original chat conversations get a reply.

The inner loop is the reply in each chat conversation. The outer loop is the product decision and the message to the voters. Both depend on the link that support created in the first step.

Where customer feedback loops break

Six failure points show up again and again:

1. No owner for the follow-up. Everyone assumes someone else will tell the customer.
2. Feedback is not linked to the work. When the fix ships, nobody knows whom to tell.
3. Status changes without messages. Moving a card to “Released” tells nobody unless a message goes out.
4. Messages sent at merge time. The fix is not live yet, and the customer tries again too early.
5. Only closing the loop on yes. Declined requests stay open forever and customers keep waiting.
6. Feedback that must be repeated. Asking a customer to post the same request again on a board adds work for them, and some will not do it.

How to measure a customer feedback loop

Measure the loop, not the volume of feedback:

Start with last quarter as the baseline and work on the slowest stage first.

How Gleap runs the loop

Gleap keeps feedback, conversations and code work on one customer record, so each stage can hand off to the next. How Gleap closes the customer feedback loop shows the full path from a customer report to the reply.

Collect

The Gleap widget collects product feedback and in-app bug reports inside your product, the inbox holds live chat and email conversations, a feature request board with a public roadmap collects votes and surveys ask customers directly. Live chat and in-app bug reporting are included on every plan; email, the feature request board and surveys need Growth or above. From Growth, Kai Support collects feature requests too: it subscribes customers who ask for a missing feature to the matching request, or files a new one when they ask for it.

Prioritize

Kai Copilot merges duplicate requests, links each to the customers who asked and drafts the changelog when it ships. With Let Kai decide, which is on by default for new projects, it also triages new requests from customers: it merges clear duplicates, accepts ideas onto the public board for voting or declines them with a reply, following any rules your team adds. Your team decides what gets built.

Ship

From Growth, Kai Code prepares pull requests for bugs and approved requests. It starts on its own when you allow it, or a teammate starts the task. Your engineers review, merge and release them.

Follow up

After a Kai Code pull request merges, Gleap by default asks a teammate to confirm the fix is live, then drafts and sends the reply on the original ticket. When your team posts an update on a feature request, or accepts, declines or releases it, everyone who voted gets that message by email. Changelogs and News for announcements come with Growth.