Mobile Forum App Development with Cursor-Based Pagination

Imagine a forum with 50,000 users, 200 sections, and 10 million posts. Without proper pagination, developing a mobile app for such a forum becomes sluggish as early as 5,000 topics — we encountered this in a production project. The client complained about stuttering when scrolling the topic list and performance drops when loading a thread with hundreds of replies. We had to completely redesign the database schema: replace offset-based pagination with cursor-based, introduce denormalized counters, and rewrite queries to leverage indexes. This sped up topic list loading by 3x and thread page loading by 40%. We'll walk you through building an architecture that keeps your forum flying even with a million posts. Our engineers have delivered over 50 mobile forums on iOS and Android, so we know every pitfall — from code signing to push notifications.

Key Technical Challenges in Mobile Forum Development

• Offset-based pagination for topic lists slows down after 5,000 records because the database scans all rows up to the offset.
• Threaded quotes (Reddit-style) are hard to read on mobile screens; use a flat structure with a quote_post_id field instead.
• Missing denormalized counters — calling COUNT(*) on every request kills performance with 10,000+ threads.
• Ignoring caching for section lists and recent topics leads to excessive network calls.
• Neglecting moderation — without spam filtering, the community quickly degrades.

How We Tackle These Challenges

For the topic list, we use cursor-based pagination: the cursor is based on (is_pinned DESC, last_reply_at DESC) for active topics and created_at for new ones. Unlike offset, the server returns a cursor (an encoded string with timestamp and id), and the client sends it in the next request. This eliminates scanning skipped rows and speeds up loading by 3x on large datasets. The threads table contains denormalized fields replies_count and last_reply_at, updated by a trigger on each new post — no more COUNT(*).

Cursor-based pagination is the standard for mobile apps where smooth scrolling matters. In practice, it saves up to 30% query time and reduces database load.

Why Denormalized Fields Accelerate the Forum?

The replies_count and last_reply_at fields in the threads table are updated by a trigger on every new post. This provides:

• Sorting by activity without COUNT(*) — saves up to 50% query time.
• Instant badge updates for unread topics on the client.
• Simple implementation of a "recent replies" screen without extra JOINs.

The update_thread_reply_count trigger fires after a post is inserted or deleted. It executes UPDATE threads SET replies_count = (SELECT COUNT(*) FROM posts WHERE thread_id = NEW.thread_id), last_reply_at = NEW.created_at WHERE id = NEW.thread_id. While this still uses COUNT(*), it runs only on changes, not on every user request. For a forum with 1,000 posts per hour, that's about 1,000 trigger calls instead of 100,000 COUNT(*) queries during active reads.

How to Implement Post Quoting in a Mobile App?

Posts are stored as a flat list with a quote_post_id field. When displayed, the quote is rendered as a nested block with a gray background, rounded corners, and a border. Tapping the quote scrolls to the original post using ScrollToRow (iOS) or LazyColumn.scrollToItem (Android). The HTML content of the quote is rendered:

• On iOS: WKWebView for complex formatting (tables, images) or NSAttributedString for plain text.
• On Android: Accompanist HtmlText for lightweight rendering; WebView only if custom styles and JavaScript are needed.

How to Implement Search, Push Notifications, and Moderation?

Search is implemented via PostgreSQL full-text search (tsvector and GIN indexes) — this ensures fast full-text search over topics and posts, including Russian morphology. For notifications, we use APNs (iOS) and FCM (Android): when a new post is created in a subscribed topic, the server sends a data payload to relevant clients, triggering a background fetch or badge update. Moderation includes server-side spam filtering (by keywords and request frequency) and a report post feature. Administrators receive push notifications about new reports.

According to the App Store Review Guidelines Section 4.2, your app must provide a minimum level of functionality — our approach guarantees this.

Our Work Process

1. Analysis — we agree on section structure, user roles, moderation requirements, and content filtering.
2. Database design — we create the boards → threads → posts schema, set up indexes, triggers for counters, and full-text search.
3. API — REST or GraphQL (Apollo) with cursor-based pagination; for search, PostgreSQL full-text search.
4. Mobile UI — develop screens using SwiftUI or Jetpack Compose: section list, topic list, thread, profile, post editor.
5. Notification integration — configure APNs and FCM, manage topic subscriptions, implement deep linking via Universal Links (iOS) and App Links (Android).
6. Testing — load test pagination, verify offline mode (caching recent data), conduct usability tests.
7. Deployment — submit to App Store and Google Play, configure code signing and provisioning profiles, use Fastlane for CI/CD.

What’s Included

• Source code of the mobile app for iOS and/or Android
• API server (if required)
• Documentation for database schema and API
• Access to repository (Git) and CI/CD (GitHub Actions, Fastlane)
• Administrator training for moderation
• One month of post-launch support

Timeline and Pricing

• MVP (sections, topic list, posts, basic text editor, cursor-based pagination) — 2–3 weeks
• Full feature set (search, unread topics, subscriptions, moderation, push notifications, deep linking) — 1–3 months

Pricing is determined individually after requirements analysis. Contact us for a project estimate — we’ll prepare a detailed quote and timeline.

Common Mistakes in Mobile Forum Development

• Using offset-based pagination without an index — slow down after 500 topics.
• Omitting denormalized counters — COUNT(*) on every request kills the database.
• Rendering HTML via UIWebView (iOS) — deprecated, slow, and memory-heavy; switch to WKWebView.
• Ignoring offline mode — the forum shows no cached data on poor connections.
• Overlooking App Store Review Guidelines (Sections 4.2, 5.1) — risk of rejection.
• Skipping obfuscation on Android (ProGuard/R8) — leaks logic.

We have over 5 years of experience and have delivered 50+ projects. We guarantee compliance with app store requirements and high performance. We’ll assess your project for free — just reach out. Order your mobile forum app development today.

How to Implement Social Features in Mobile Apps?

We design in-app chat not as “just WebSocket + messages” but as a system with offline access, history display under poor connection, typing indicators, read receipts, and push notifications when the app is closed. Our experience shows that all this must work on Android 8 with 512 MB RAM without ANR — otherwise users simply leave. With over 50 integrated social modules — from startup MVPs to enterprise platforms — we know where the architecture typically breaks. Contact us to achieve similar results for your product.

How do we approach chat development?

Choosing the protocol and storage is the first point where mistakes are made. WebSocket, XMPP, or a ready-made SDK — each option dictates time budget and reliability.

• Ready-made chat SDK (SendBird, Stream Chat, Cometchat) provides UI components, server infrastructure, push notifications, and moderation. Fast, reliable, but vendor lock-in and recurring costs. For MVP — optimal. One client cut time-to-market by 2 months using Stream Chat.
• Firebase Realtime Database / Firestore — for simple chats without scalability requirements >100K concurrent users. Realtime Database is more convenient for ordered message lists, Firestore for structured data. Limitation: typing indicators and presence are implemented separately via onDisconnect().
• Custom backend with WebSocket — full control, maximum customization. Stack: Node.js + socket.io or Phoenix Channels (Elixir), PostgreSQL + Redis for pub/sub. On mobile: Starscream (iOS Swift), OkHttp WebSocket (Android), socket_io_client (Flutter). Requires 2–3x development time but gives zero vendor risk. In one project, we chose custom WebSocket and reduced licensing costs by 40% compared to SendBird. Custom WebSocket implementation delivers 3x lower latency than Firebase on high-concurrency workloads.

Why is it important to plan offline mode in advance?

Offline mode is the most labor-intensive part of any chat. Messages are stored in SQLite (iOS: GRDB, Android: Room) with a local ID, synchronized upon connection restoration. Conflicts during simultaneous sending are resolved via vector clocks or server-timestamp ordering. If you don’t build this into the architecture from the first sprint, you’ll have to rewrite half the code 2–3 weeks before release. On one project handling 10 million messages daily with 500,000 DAU, we reduced sync time by 60% and made average delivery delay under 150 ms. Cursor-based pagination reduces data duplication by 10x compared to offset pagination on feeds with over 10,000 items — when new items are inserted, the cursor doesn’t shift, and the user doesn’t see duplicate content.

VoIP: CallKit, ConnectionService, and WebRTC

VoIP in a mobile app splits into two scenarios: system UI (looks like a phone call) or in-app call. CallKit (iOS) integrates via CXProvider + CXCallController and allows showing incoming calls on the Lock Screen, working with Bluetooth, and interrupting other audio. The app launches via VoIP push (PKPushKit) even when killed — essential for receiving calls.

On Android, the analog is ConnectionService API. Integration is more complex, behavior varies between manufacturers (Xiaomi, Samsung with their battery optimization aggressively kill background processes). WebRTC — transport protocol for P2P media. Signaling server (SDP, ICE candidates) — usually over the same WebSocket channel. STUN/TURN are mandatory: without TURN ~15–20% of users behind symmetric NAT won’t see the call. coturn — open source solution, Twilio NTS and Metered TURN — managed.

What Are the Best Practices for Feed and Reactions?

Infinite feed — UICollectionView with UICollectionViewDiffableDataSource on iOS, LazyColumn with Paging 3 on Android. Pagination via cursor-based approach — it doesn’t shift when new items are inserted, unlike offset. Reactions (emojis on messages): each reaction is a record (message_id, user_id, emoji), aggregated on the server GROUP BY emoji. WebSocket event reaction_added updates the counter in real-time. Grouping with GROUP BY emoji is 5x faster than per-message count updates. Appearance animation — via withSpring (Reanimated) or Core Animation spring. In a social network project, we handled up to 80,000 concurrent connections on a single instance — the feed remained responsive.

Push notifications for social events: @mention, reply, new follower — via APNs and FCM. For rich notifications (media preview) on iOS — Notification Service Extension, which loads media before display. After implementing such notifications, user retention increased by 30%.

What deliverables do you receive?

We deliver not just code — here is the full list:

1. Data schema design (SQLite, Firestore, PostgreSQL) considering offline-first and scaling up to 1 million users.
2. Client-server protocol implementation (WebSocket, REST, GraphQL) with reconnection and heartbeat support.
3. Push notification integration (APNs, FCM) with certificate generation and key configuration.
4. TURN server setup or managed provider selection (e.g., Twilio NTS) for VoIP.
5. API documentation and migration schema (including rollback plan).
6. Access to repository, CI/CD (GitHub Actions + Fastlane), TestFlight / Google Play Console.
7. Team training (including code review for the first 2 sprints) and knowledge transfer.
8. On-call support for 2 weeks after release.

How to avoid typical mistakes in chat development?

• Lack of reconnection strategy. Client simply disconnects without a queue of unsent messages. Solution: heartbeat, exponential backoff, local storage of outgoing messages with pending flag.
• Using offset pagination in feed. When new posts are inserted, the user sees duplicates — scrolling breaks. Solution: cursor-based pagination.
• Ignoring battery optimization on Android. ConnectionService doesn’t survive until incoming call. Solution: foreground service with persistent notification or integration via Firebase Cloud Messaging for wake-up.
• Error in choosing chat protocol. Bare WebSocket without a protocol on top — reinventing the wheel. Platform-agnostic JSON or MessagePack with type flag.

The technology stack we typically apply on a mobile chat project includes: iOS (Swift 5.9+, SwiftUI, Combine, async/await, Starscream, GRDB), Android (Kotlin, Jetpack Compose, OkHttp WebSocket, Room, Hilt DI), cross-platform (Flutter 3.x/React Native), backend (Node.js + socket.io or Phoenix Channels + PostgreSQL + Redis), push (APNs/FCM), and VoIP (WebRTC + coturn).

⏱ Estimated timelines

Cost is calculated individually after analyzing your technical specification and existing architecture. Contact us for a project estimate — we will offer two options: fast implementation via ready-made SDKs or a fully customized solution. Get a consultation and accurate estimate within 2 business days. Order chat development today — we guarantee correct operation on Android 8+ and iOS 14+. Reach out to discuss your project's specific needs — we'll propose the optimal architecture.