Implementing AI Sentiment Analysis in a Mobile App
We often face the challenge: how to automatically detect user dissatisfaction before they write a negative review on the App Store? Sentiment analysis in a mobile context solves precisely this — review moderation, real-time chat analysis, and in-app feedback monitoring. The choice between an on-device model and a cloud API determines everything: latency, privacy, cost, and accuracy. Our experience shows that the right architectural choice reduces the number of public negative reviews by 30%.
Why On-Device Analysis Provides Better Privacy
Cloud API (OpenAI, Google Cloud Natural Language, AWS Comprehend) delivers over 90% accuracy on structured text, but each request costs money and requires a network connection. For example, OpenAI charges ~$0.002 per 1K tokens; batch of 1000 reviews (50 words each) costs about $2. It's fine for product analytics (reviews, surveys), but not for real-time analysis of every typed character. On-device (CoreML + BERT, TensorFlow Lite + MobileBERT) is private, works offline, and has zero network latency. The downside: the model weighs 40–80 MB, accuracy is lower on ambiguous cases, and maintenance is harder (retraining requires an app update or OTA model delivery). An on-device model is 3 times faster in response time (< 50 ms vs 200–500 ms).
| Parameter | On-device | Cloud API |
|---|---|---|
| Latency | < 50 ms | 200–500 ms |
| Privacy | Yes | Data goes to server |
| Accuracy | 80–85% | 90–95% |
| Cost | Fixed (model size) | $0.002/1K tokens |
| Offline | Yes | No |
On iOS: CoreML with DistilBERT-sentiment model (converted via coremltools from a Hugging Face checkpoint). Inference < 50 ms on iPhone 12+. Initialize MLModel at app launch, not on first call — otherwise you get a 300 ms delay. On Android: TensorFlow Lite with MobileBERT — similar approach. Initialize Interpreter in Application.onCreate() on a background thread.
What Sentiment Granularity Should You Choose?
Basic positive/negative/neutral is too coarse for most tasks. Fine-grained sentiment offers more:
- Aspect-based sentiment: "Delivery is great, but packaging is bad" — not one sentiment, but two for different aspects.
- Emotion classification: joy, anger, sadness, fear, surprise — more valuable than just +/- for product analysis.
- Intensity: very negative vs slightly negative — affects response priority.
In practice: if you need aspect-based, use a server-side model (flair, spaCy with custom NER + sentiment pipeline) or GPT with structured output. On-device models can only handle 3-class classifiers without aspects.
Concrete Case: Analyzing In-App Reviews (from Our Practice)
One of our clients — a food delivery app — often received negative reviews about packaging quality. We implemented on-device sentiment analysis on the feedback screen. The user types text → CoreMLSentimentAnalyzer.analyze(text) returns SentimentResult(label:score:) with a 500 ms debounce → if negative score > 0.7, before submitting we show "We're sorry you're having trouble. Would you like to contact support now?" → redirect to chat instead of a public review. Result: the number of public negative reviews decreased by 30% in the first month. This saved approximately $5,000 in customer acquisition costs. Technically: the DistilBERT-sentiment model takes 50 MB, inference < 50 ms, result stored in ReviewDraft and sent to the server.
How to Ensure Multilingual Support?
A separate model per language gives better accuracy but increases bundle size. XLM-RoBERTa is a multilingual model — one for all languages, performs worse on each individual language, but much better than nothing. For Russian texts: DeepPavlov's rubert-base-cased-sentiment offers good accuracy on CIS data, convertible to CoreML/TFLite.
Sentiment analysis — a natural language processing technique used to determine the emotional tone of text (source: Wikipedia).
Step-by-Step Guide: How to Integrate Sentiment Analysis into a Mobile App
- Define the scenario: realtime vs batch, on-device vs cloud, language of texts, required granularity.
- Choose the model: pre-trained CoreML/TFLite for quick integration or cloud API for high accuracy.
- Integrate the model into the app, considering the platform (iOS/Android) and framework (SwiftUI/UIKit, Jetpack Compose).
- Set activation thresholds for business logic (e.g., negative review score > 0.7).
- Test on representative production data.
- Deploy and monitor metrics (latency, accuracy, number of notifications).
Common Integration Mistakes
- Initializing the model on first call instead of at app launch — adds 300+ ms delay.
- Using one model for all tasks without considering context (e.g., reviews vs chats).
- Neglecting OOV (out-of-vocabulary) word handling — reduces accuracy.
- Ignoring multilingual needs: for Russian, XLM-RoBERTa gives 75% accuracy, while specialized ruBERT gives 88%.
What Is Included in the Work?
- Analysis of the use case and architecture selection (on-device vs cloud, realtime vs batch).
- Model integration (CoreML/TFLite/Cloud API) with your stack.
- Customization of thresholds for business logic.
- Documentation of the solution (architecture diagrams, API references).
- Access to model source code and training scripts.
- Training for your team (2-hour session).
- Support for 1 month after launch (bug fixes, performance tuning).
Our Process
We define the use case (realtime vs batch, on-device vs cloud), language of texts, required granularity. We design the architecture, select the model, integrate it, set thresholds, test on representative production data. The final stage is deployment and monitoring.
Timeline Estimates
Integration of a ready-made model (Cloud API or pre-trained CoreML/TFLite) with basic positive/negative/neutral — 3–5 days. Custom model with fine-tuning on your data, aspect-based analysis, multilingual support — 3–5 weeks. Cost is calculated individually, starting from $1,500 for basic integration. Our experience: 5+ years in mobile development, 20+ projects with AI/ML. We guarantee quality results.
Contact us for a consultation. Order integration today — get a commercial proposal.