How to Add an In-App Feedback Board to Your iOS App

To add an in-app feedback board to an iOS app, you install a native SDK like UserJot's Swift package, initialize it with your project ID on launch, and present the board as a native sheet from your settings screen or menu so users can post ideas and vote without leaving your app.

When Chris, the solo developer behind Amy and Ellie, shared how he grew his iOS app from 10 beta testers to 200 active users, the change that moved the needle most wasn't a redesign or an onboarding rewrite. It was putting a feedback board right inside the app. He called it "hands down the most impactful thing" he did for keeping users around.

Collecting product feedback on iOS is a different problem from collecting it on the web. On a desktop browser, opening a new tab is effortless. On an iPhone, kicking someone out of your app into Safari to fill out a web form almost guarantees they will close the tab and move on. Worse, when a frustrated mobile user hits a bug or a missing feature and has nowhere inside the app to report it, they go to the one public outlet Apple gives them: the App Store review tab. That is how a fixable bug or a straightforward feature request turns into an angry 1-star review that sits on your product page forever.

Why mobile users don't fill out web feedback forms

Think about how people actually use an iOS app. Someone opens your app for forty seconds while waiting for coffee, logging lunch at the table, or checking their plan for the afternoon. When they run into a rough edge or wish a screen worked differently, you have about ten seconds of their attention before they lock their phone.

Most mobile apps waste that window by making feedback feel like homework. If tapping "Send Feedback" opens a mail composer, the user has to switch contexts, come up with a subject line, and type out which screen they were looking at on a phone keyboard. If it kicks them out to Mobile Safari and asks them to create a separate forum account or fill out a five-field web survey, they swipe back immediately.

The users who do push through that friction are rarely a representative sample of your audience. Polite users who ran into a confusing flow simply stop opening your app after a few days and quietly delete it from their home screen. Meanwhile, the user who just lost five minutes of work to a bug heads straight to the App Store, taps one star, and writes a two-sentence warning to future downloads before you even know something broke.

Even when a loyal user takes the time to send a support email, their message disappears into a private inbox. They have no idea if thirty other people asked for the same thing or if their note was archived five seconds after it arrived. Putting a feedback board inside the app fixes both halves of that problem: it catches frustration inside your product before it spills onto the App Store, and it shows users that a real person is listening.

How an in-app feedback board changes user behavior

A shared feedback board works on mobile because tapping a vote button is ten times easier than typing a paragraph on glass.

When a user opens your in-app board to ask for dark mode or an Apple Health sync, they immediately see that two dozen other people already posted the same idea. Instead of writing a new ticket from scratch, they tap once to upvote the existing thread and maybe leave a short comment about how they'd use it.

That visibility changes how people feel about a young app. A missing feature feels like a dead end when you think nobody else cares and the developer isn't paying attention. When a user sees their exact request sitting near the top of the board with an In Progress or Planned badge on it, they stick around for the next update instead of downloading a competitor.

On your side as the developer, the board replaces guesswork with a sorted list. Instead of building whichever feature was mentioned in the most recent support email, you can see whether an idea matters to two users or two hundred.

 

How UserJot works inside an iOS app

We built UserJot so you can run your feedback boards, public roadmap, and changelog in one workspace and present them directly inside your iOS or macOS app through our open-source Swift SDK at github.com/UserJot/userjot-ios.

When a user opens the board from your app and starts typing a new post, UserJot runs an embedding search in real time to surface similar existing requests before they submit a duplicate. If two users still phrase the same idea differently, you can merge the threads in your dashboard so all the votes and comments roll into one place without double-counting anyone who voted on both.

Everything inside the sheet adapts to mobile screens without pinching or zooming. Users can browse requests, search existing ideas, vote, comment, and attach photos straight from their camera roll. You can match the board to your app's accent color and set the theme to follow the user's iOS light or dark mode automatically.

Adding the UserJot Swift SDK in a few minutes

The UserJot Swift SDK installs through Swift Package Manager and supports iOS 15.0+ and macOS 12.0+ with Swift 6.1 and Xcode 16.3+. In Xcode, open File, then Add Package Dependencies, and paste https://github.com/UserJot/userjot-ios.

Once the package is added to your target, call UserJot.setup(projectId:) once when your app launches and call UserJot.showFeedback() from any button action:

import UserJot
 
// One line setup
UserJot.setup(projectId: "YOUR_PROJECT_ID")
 
// Add feedback button anywhere
Button("Send Feedback") {
    UserJot.showFeedback()
}

The setup call returns right away on the main actor and loads your board configuration in the background so it never slows down app launch. If a user taps your feedback button before that background call finishes, or if they launch the app offline and reconnect a moment later, the SDK waits and presents the sheet cleanly.

If you're building with SwiftUI on iOS, you can also drive the feedback sheet from state using the .userJotFeedback view modifier:

struct SettingsView: View {
    @State private var showingFeedback = false
 
    var body: some View {
        List {
            Button("Send Feedback") {
                showingFeedback = true
            }
        }
        .userJotFeedback(isPresented: $showingFeedback)
    }
}

On iOS, UserJot opens as a native sheet. You can pass presentationStyle: .sheet for a full-height sheet or presentationStyle: .mediumSheet when you want a lighter half-screen sheet over the current view. Beyond the feedback board, you can also open your roadmap with UserJot.showRoadmap() and your changelog updates with UserJot.showChangelog(), or UserJot.showUpdates() in version 0.4 and up. Our Swift SDK installation guide walks through every step for both SwiftUI and UIKit apps.

How Chris used his board to fix week-one retention

When Chris launched the early beta of Amy, his food journal and calorie tracker, new users loved the clean interface on day one. By day four, though, a surprising number of them stopped logging meals.

Without an in-app board, he would have had to guess why people were dropping off. Once the board was live inside the app, the reason became obvious within days: a request for saving and re-adding frequent meals shot straight to the top of the vote list. Users were eating the same breakfast and lunch most days of the week, and typing the same four ingredients from scratch every morning made them want to quit.

Instead of spending weeks building secondary charts or social sharing features he had originally planned, Chris built a quick-add flow for saved meals. Week-one retention jumped as soon as that update shipped because the board pointed him straight at the friction that was making new users give up.

Closing the loop when you ship an App Store update

Shipping what users asked for only helps retention if those users actually find out you built it. On iOS, most people have automatic app updates turned on in the background, and almost nobody reads the "What's New" notes on the App Store page. If a user asked for a feature in January and you ship it quietly in February, they might never notice.

UserJot closes that loop automatically through status updates. Every request moves through six clear statuses: Pending, Reviewing, Planned, In Progress, Completed, and Closed. When you move an item to Planned or In Progress, it appears on your public roadmap right away with no extra step, which cuts down on repeat requests while you're still writing the code.

The moment your new build clears App Store review and you change the request's status to Completed, UserJot sends an email to everyone who posted, voted, or commented on that thread. In the changelog editor, our assistant Juno can draft your release announcement from the requests you completed since your last post, and you can link those completed requests right underneath the entry. Getting a personal email that says the exact feature you voted for is live in today's update brings lapsed users right back into your app.

Where to put the feedback button in your iOS app

Chris puts his feedback button inside the Settings screen of Amy and Ellie. That placement works well for almost every iOS app because Settings is the first place people check when they want to report a problem, and it keeps your primary tab bar clean.

Other natural spots include a profile menu, a help and support section, or a quick link right after a user finishes a core workflow like logging an entry or exporting a file. Avoid interrupting users with pop-up prompts while they are in the middle of a task; let them finish what they opened the app to do first.

If you want to keep bug reports separate from feature ideas, you can create multiple boards in UserJot and pass the board slug directly to showFeedback(board:):

// Bug reports go to one board
Button("Report Bug") {
    UserJot.showFeedback(board: "bugs")
}
 
// Features go to another
Button("Request Feature") {
    UserJot.showFeedback(board: "features")
}

Splitting bugs and features onto separate boards gives frustrated users a dedicated "Report Bug" button inside your app when something breaks, while keeping your main feature board focused on what to build next.

Identifying signed-in users from your app

Nothing breaks the native feel of an iOS app faster than asking a user who already signed in with Apple or email to log in a second time just to upvote a feature request.

When you call UserJot.identify(...) after your app restores or creates an authenticated session, UserJot links that person's posts, votes, and comments directly to their account and email address:

// Know who's giving feedback
UserJot.identify(
    userId: "user_123",
    email: "john@example.com",
    firstName: "John",
    lastName: "Doe"
)

Passing the user's stable ID and email means they can vote and post right away, and they'll automatically receive the status email when a feature they voted on moves to Completed. When they sign out of your app, call UserJot.logout() to clear the session.

If you want cryptographic verification so nobody can spoof another user's ID, you can turn on automatic login and require signed tokens on the Starter plan and up, generate an HMAC-SHA256 signature of the userId using your project secret on your backend, and pass it via the signature parameter. You can find server-side signing snippets in Node.js, Python, PHP, and Ruby in our Swift authentication guide, along with full view patterns in our SwiftUI common flows guide.

Getting started with UserJot on iOS

You don't need weeks of backend work or an enterprise budget to put a feedback board inside your iOS app. UserJot's Free plan is $0 a month forever and includes unlimited end users, unlimited posts, two feedback boards, a public roadmap, and a changelog. When your app grows, the Starter plan at $29 a month adds up to five boards, private boards, moderation, automatic login, and a custom domain like feedback.yourapp.com, while the Professional plan at $59 a month unlocks up to 100 boards, public identity masking, and removing the UserJot badge. The REST API and MCP server are on every plan, including Free.

To add a board to your next TestFlight or App Store build, head over to our Swift SDK installation guide, grab your project ID from the dashboard, and drop UserJot.setup(projectId:) into your app startup.

Frequently asked questions

How do I add a feedback board to my iOS app?

Install the UserJot Swift SDK in Xcode using Swift Package Manager with the repository URL https://github.com/UserJot/userjot-ios. Call UserJot.setup(projectId: "YOUR_PROJECT_ID") once in your App initializer or AppDelegate, then present the board from any button using UserJot.showFeedback() or the SwiftUI .userJotFeedback(isPresented:) modifier.

What iOS versions does the UserJot Swift SDK support?

The current UserJot Swift SDK supports iOS 15.0 and later, as well as macOS 12.0 and later, using Swift 6.1 and Xcode 16.3+. If your app uses a custom container or WebView setup, you can also call await UserJot.feedbackURL(), await UserJot.roadmapURL(), and await UserJot.updatesURL() directly.

Do users have to create a separate account to leave feedback in my iOS app?

No, you can pass your signed-in user's ID, email, and name with UserJot.identify(...) so their feedback and votes connect to their existing app account automatically. Guest posting is on by default on every plan, so signed-out visitors can post, vote, and comment without creating an account.

How does an in-app feedback board reduce 1-star App Store reviews?

Most angry 1-star reviews happen because a user hits a bug or a frustrating workflow and has no fast way to tell the developer inside the app. Putting a "Report Bug" or "Send Feedback" sheet in your settings screen catches that frustration in the moment and lets the user see that you are actively tracking and fixing the issue.

Can I show my product roadmap and changelog inside my iOS app too?

Yes, the same Swift SDK includes UserJot.showRoadmap() to open your public roadmap and UserJot.showChangelog(), or UserJot.showUpdates(), to show your latest release notes in a native sheet. Any request you move to Planned or In Progress in UserJot appears on that roadmap automatically.