FeedbackWall
Architecture Guide

iOS User Feedback
Architecture

Design patterns for building a robust feedback system. From data flow to user experience considerations.

See the architecture ↓

Quick Overview

A good feedback architecture has three layers: Presentation (how surveys appear), Logic (when to show them), and Data (how responses are collected and sent). Keep each layer independent for flexibility. Or use FeedbackWall - we handle all three layers for you.

The challenge

Why architecture matters

Without structure

Feedback code scattered throughout the app. Inconsistent timing. Hard to maintain or update.

With architecture

Centralized logic. Easy to change triggers. Surveys managed from one place.

The architecture

Three-layer feedback system

1

Presentation Layer

How surveys look and appear to users. This should be completely decoupled from your app's UI logic.

Modal presentation: Surveys appear as sheets, not embedded in views
Consistent styling: Match your app's design language
Easy dismiss: Users can close without friction
FeedbackWall approach: Native iOS sheets that present on top of any view. Themeable from dashboard.
2

Logic Layer

When and where to trigger surveys. This is where targeting, frequency limits, and eligibility live.

Event-based triggers: Fire on specific app events
Frequency control: Don't show too often
Sample rate: Show to a percentage of users
User targeting: Different surveys for different segments
FeedbackWall approach: Call showIfAvailable(trigger:) at key moments. SDK handles eligibility checks.
3

Data Layer

How responses are collected, validated, and transmitted to your backend.

Response validation: Ensure data is complete before sending
Network handling: Retry failed submissions
User attribution: Link responses to user IDs
Offline support: Queue responses when offline
FeedbackWall approach: SDK handles all data transmission. Responses sent to dashboard automatically.
Data flow

How data moves through the system

1

App event fires

→
2

SDK checks eligibility

→
3

Survey fetched from server

→
4

User responds

→
5

Response sent to API

Design patterns

Common implementation patterns

Centralized feedback manager

Single object that handles all feedback logic. Easy to test and maintain.

class FeedbackManager {
    static let shared = FeedbackManager()
    
    func trackEvent(_ event: String) {
        FeedbackWall.showIfAvailable(trigger: event)
    }
}

Event-driven architecture

Decouple feedback triggers from business logic using events.

NotificationCenter.default.post(
    name: .orderCompleted,
    object: nil
)

// FeedbackManager listens and triggers

Dependency injection

Inject feedback service for testability.

protocol FeedbackService {
    func trigger(event: String)
}

// Use real implementation in app
// Use mock in tests
Considerations

Architecture decisions

Build vs. buy

Building a feedback system from scratch requires survey UI, backend infrastructure, analytics dashboard, and ongoing maintenance. Using FeedbackWall gives you all of this immediately.

Where to store config

Survey configuration should live server-side, not in your app. This lets you change surveys without app updates.

User privacy

Consider what data you collect with feedback. User IDs help but aren't required. Anonymous feedback is still valuable.

Performance impact

Feedback systems should be lightweight. Lazy loading, minimal network calls, and efficient caching matter.

FAQ

Common questions

Should I build my own feedback system?

Only if feedback is core to your business model. Otherwise, the engineering effort rarely justifies the cost.

How do I handle offline users?

Queue responses locally and send when connectivity returns. FeedbackWall handles this automatically.

Where should trigger logic live?

In a centralized manager or service, not scattered throughout your views. This makes it maintainable.

How do I test feedback flows?

Use dependency injection with mock feedback services. Or use FeedbackWall's debug mode in development.

Skip the architecture work

FeedbackWall handles all three layers for you. Focus on your app, not your feedback infrastructure.

Start free trial →

14-day free trial. Production-ready architecture included.