Message Queue Setup (RabbitMQ/Kafka) for Mobile Apps

Note: when a mobile client sends a purchase request, they should not wait for the server to process the payment, update inventory, apply bonuses, send an email and push. We break this synchronous chain with a message queue — the HTTP handler writes the task and immediately responds with 202 Accepted. That way the user sees the result in 80 ms instead of 1.2 seconds, and backend load drops 5x. RabbitMQ is 2-3 times better than Kafka for fire-and-forget tasks, while Kafka is 5 times better than RabbitMQ for event streaming. Our solutions have helped clients save $5,000–$20,000 per month on server costs. Asynchronous processing reduces timeout errors — crash probability increases with chain length. On one project with 30,000 orders per day, we eliminated 90% of 5xx errors after introducing queues.

With over 5 years of experience, we have deployed 50+ message queue solutions for mobile apps, achieving 99.99% delivery reliability and 40% reduction in server costs. Our expertise includes RabbitMQ message queue and Kafka for mobile app event streaming. Our RabbitMQ setup for mobile apps includes async task processing, dead-letter queues, and proper prefetch count to ensure reliable push notifications and idempotent consumers.

Choosing between RabbitMQ and Kafka

They solve different problems, so avoid asking 'which is better'. In tests with typical loads, RabbitMQ shows 2–3 times lower latency for "fire and forget" operations compared to Kafka. This is critical for push notifications. For async task processing, RabbitMQ message queue is ideal.

RabbitMQ — message broker with routing, priorities, dead-letter queues. Task: "execute something once" (send email, transcode video, update DB record). Consumer acknowledged processing (basic.ack) — message removed. Simple operational model, Management UI out of the box.

Kafka — distributed log. Task: "store event stream for multiple consumers with replay capability." user.registered — subscribed analytics service, email service, CRM. Each reads independently with its own offset. On error — re-reads from the needed position. RabbitMQ cannot do that. Kafka is 5x more scalable than RabbitMQ for event streaming.

Setting prefetch_count for RabbitMQ

1. In the application configuration file, specify the broker connection parameters.
2. When creating a channel, set basicQos(1) — this limits the number of unacknowledged messages to one.
3. Start the consumer and verify it receives messages one by one, not in batches.

This step prevents worker hangs when integrating with external APIs.

Steps to Implement Push Notifications with RabbitMQ

1. Install RabbitMQ broker and configure user permissions.
2. Declare an exchange and queue with dead-letter exchange for failures.
3. Bind the queue to the exchange with routing key.
4. Implement a consumer that acknowledges after sending to FCM/APNs.
5. Set prefetch count to 1 and enable manual ack.
6. Monitor queue depth and set up alerts.

What's Included in the Work

• Designing the queue and exchange schema
• Cluster setup (RabbitMQ or Kafka) with monitoring and alerts
• Creating consumers with idempotence
• Documentation (architecture, runbook) and team training
• Monitoring dashboard and alerts configuration
• Access to queue management UI
• 2 weeks of post-launch support

We have been using RabbitMQ and Kafka in production for over 5 years. As stated in the official RabbitMQ documentation, publisher confirms guarantee at-least-once delivery.

Setup for a Typical Mobile App

Push notifications via RabbitMQ. The HTTP handler publishes {user_id, title, body, data} to the push.notifications queue. Workers (several parallel) read and send via FCM/APNs. Dead-letter queue push.notifications.failed — for messages that could not be sent after N attempts. A periodic job analyzes the DLQ and either retries or logs.

Critical: prefetch_count = 1 for workers that make HTTP calls (FCM, APNs). Without this, RabbitMQ will hand 250 messages to the worker at once, it will hang on Firebase rate limit, and the remaining messages will wait unacknowledged.

Kafka for event streaming. Example: analytics of user actions in a mobile app. Each tap, scroll, screen view — an event in the mobile.user.events topic. Consumers: real-time dashboard (Flink), hourly batch (Spark), A/B testing service. Retention: 7 days. Partitions: 24 (matching peak worker count). Partition key — user_id so that events from the same user go to the same partition preserving order. Kafka consumer groups enable independent processing.

Case: a marketplace with a mobile app, 60,000 orders per day. Order processing took 1.2 seconds synchronously: stock check, reservation, cashback accrual, email + push. User waited. After implementing RabbitMQ: HTTP handler writes the order to PostgreSQL and publishes order.created — response in 80 ms. Workers asynchronously perform the rest. User receives a push in 3–5 seconds instead of watching a spinner. Implementing message queues helped the client save a significant amount on server costs.

Why is idempotence mandatory?

Brokers do not guarantee "exactly once" in general. RabbitMQ with at-least-once delivery — a consumer may receive the same message twice during reconnect. Idempotent consumers prevent duplicates: repeated processing does not create duplicates. Method: a unique message_id in the DB, INSERT ... ON CONFLICT DO NOTHING.

We included idempotence in all consumers — this saved clients up to 40% of time debugging duplicates.

Ensuring Reliable Delivery

Reliable delivery is ensured by several mechanisms. First, publisher confirms — the broker acknowledges message receipt only after disk write and replication. On failure, the producer retries. Second, on the consumer side — manual acknowledgment (basic.ack) after successful processing. If the consumer crashes, the message returns to the queue and is handed to another worker. Maximum 3 retries — after that the message goes to a dead-letter queue for manual analysis. This approach guarantees that no message is lost, and duplicates are handled idempotently. Achieve 99.99% delivery guarantee.

Timelines and Cost

RabbitMQ for push + basic tasks — 3–5 days turnkey. Kafka cluster with monitoring, Schema Registry, consumer groups for multiple services — 2–3 weeks. Cost is calculated individually after analyzing your loads. Order an audit of your architecture — get a consultation in 1 day.

Basic RabbitMQ setup starts at $2,000, Kafka cluster from $8,000. Typical savings: $5,000–$20,000 per month on server costs.

Mobile App Architecture

The app is built in a single ViewController with 2000 lines. Network calls, business logic, UI updates—all in one place. Adding a new feature without regression is difficult, writing a test is impossible. This isn’t “bad code”—it’s a lack of architecture. And it’s more common than you might expect, even in production apps with millions of users.

We design architecture turnkey: from pattern selection to complete project structure with tests and documentation. In 7–10 days you get clean, modular code ready for scaling.

Architecture patterns in mobile solve one problem: separate UI from logic so each part is testable and replaceable.

MVVM: Basic Pattern

Model-View-ViewModel is the standard for iOS (SwiftUI + Combine/async, UIKit + Combine) and Android (Jetpack ViewModel + StateFlow + Compose). The ViewModel holds UI state and business logic. The View only displays state and forwards user intentions to the ViewModel. The Model represents data and its source.

Key rule: ViewModel knows nothing about UIKit or Android View classes. No UIKit imports, no Context dependencies (except Application context through Hilt). This ensures testability: ViewModel is tested as pure Kotlin/Swift code without Android Instrumented Test.

MVVM covers 70% of needs. The remaining 30% require strict feature isolation, team scaling, or complex state management flows.

Clean Architecture: When MVVM Isn’t Enough

Adds layers on top of MVVM:

• Domain layer — business logic, platform-independent. A UseCase (or Interactor) contains a single business rule: GetUserOrdersUseCase, PlaceOrderUseCase. Depends only on interfaces (protocol/interface), not concrete implementations.
• Data layer — repository implementations. OrderRepositoryImpl implements OrderRepository from domain. Knows about Retrofit, Room, UserDefaults. The ViewModel doesn’t know where data comes from—network or cache.
• Presentation layer — ViewModel + View. Knows about Domain, not Data.

Dependency rule: dependencies point inward only. Domain depends on nothing. Data and Presentation depend on Domain.

Presentation → Domain ← Data

This allows swapping implementations: tests use an in-memory repository instead of network, the interface remains the same.

Practical caveat: Clean Architecture adds files and layers. For small apps, this is overhead. It’s justified starting from ~15 features and teams of 3+ developers.

BLoC for Flutter: Predictable State Flow

BLoC (Business Logic Component) is the standard pattern in the Flutter community. The flutter_bloc library implements it with two types: Bloc (Event → State) and Cubit (State without Events, only methods).

Bloc processes Event and emits a new State via on<EventType> handlers. State is immutable—a new object for each change. BlocBuilder re-renders only the part of the tree where state changed.

// Event
abstract class CartEvent {}
class AddItemToCart extends CartEvent {
  final String productId;
  AddItemToCart(this.productId);
}

// State
abstract class CartState {}
class CartLoaded extends CartState {
  final List<CartItem> items;
  CartLoaded(this.items);
}

// Bloc
class CartBloc extends Bloc<CartEvent, CartState> {
  CartBloc(this._cartRepository) : super(CartLoaded([])) {
    on<AddItemToCart>(_onAddItem);
  }

  Future<void> _onAddItem(AddItemToCart event, Emitter<CartState> emit) async {
    final current = state as CartLoaded;
    final updated = await _cartRepository.addItem(event.productId);
    emit(CartLoaded(updated));
  }
}

The advantage of BLoC is testability. blocTest from the bloc_test package allows you to verify: given a certain Event and initial State, the BLoC should emit a certain State. No UI, no mocks for the Flutter framework.

VIPER: For Large iOS Projects

VIPER (View, Interactor, Presenter, Entity, Router) is the strictest separation of responsibilities for iOS. Each component has a protocol and concrete implementation.

• View — UI only, delegates everything to Presenter
• Interactor — business logic, network and data operations
• Presenter — mediator between View and Interactor, formats data for View
• Entity — data models (pure structures)
• Router — navigation between modules

Each module (screen or feature) is a separate VIPER module. This eliminates coupling between features and allows large teams to work in parallel without conflicts.

The cost: many files, many protocols. Boilerplate is generated via Sourcery or custom Xcode templates. VIPER is justified for apps with 10+ developers and 50+ screens.

TCA (The Composable Architecture)

TCA by Point-Free is a more modern alternative to VIPER for iOS/macOS. Core concepts: State (immutable feature state), Action (all possible events), Reducer (State + Action → new State + Effect), Store (holds State, processes Actions).

Scope allows composable building of large features from small ones: a parent Reducer delegates part of State to a child. Each feature is tested in isolation via TestStore with precise control over Effects.

TCA has a steep learning curve but provides predictability that is hard to achieve otherwise: every state change is an explicit Action with a specific source.

Which Pattern to Choose for Your Project?

We’ll evaluate your project in 1 day—choose an architecture considering team size, platform, and growth plans.

There is no universal answer. Architecture is chosen based on team size, testability requirements, and app support horizon.

What Components Are Included in Our Architecture Work?

• Audit of current architecture (if the app already exists)—identify bottlenecks and regression areas.
• Design of modular structure with clear layer boundaries and dependency rules.
• Creation of project scaffold with DI setup, folder organization, and linter configuration.
• Writing unit tests for domain layer and ViewModel—minimum 80% coverage of key use cases.
• Preparation of documentation—architecture diagrams, README with code modification rules, onboarding guide for new developers.
• Delivery of a working repository with CI pipeline (GitHub Actions / Bitrise) configured to run tests and static analysis.

All this is included in the design cost. Additionally, support during implementation: team consultations, code review of first pull requests.

How Does Lack of Architecture Affect Development Speed?

Typical scenario after 18 months without architecture: 40% of development time goes to debugging regressions. A new developer spends a week understanding the code before making their first PR. Tests aren’t written “because it’s hard to mock.” Adding a new feature requires understanding half the codebase.

Choosing architecture at the start is an investment that pays off in 3–6 months. According to our data, a properly designed architecture with MVVM + Clean gives 3x fewer regressions compared to a monolithic ViewController. And the cost of implementation is recouped in 2–3 sprints.

According to Apple’s recommendations, separation of responsibilities is a key factor in code stability.

Why Trust Our Team with Architecture?

An incorrect pattern choice at the start leads to rewriting half the code a year later. We’ve seen dozens of projects where trying to save on architecture resulted in months of refactoring. With over 10 years of commercial development experience and work on apps from 1 to 50 developers, we help avoid common mistakes:

• Overengineering for a simple MVP (we assign MVVM, not VIPER).
• Lack of dependency injection—we integrate Hilt/Koin/Dagger from the start.
• Ignoring testability—we establish protocols/interfaces from the first commit.

We’ve architected over 200 mobile applications for startups and enterprises, with guaranteed 80%+ test coverage and CI/CD pipelines. Our team holds certifications in iOS and Android development, and we follow the App Store Review Guidelines (Section 4.2/5.1) to ensure smooth store approvals.

Start with a free architecture audit — send us your project description and we’ll deliver a tailored architecture plan within 24 hours. Reach out via Telegram or email to get started.