Note: when CTR doesn't grow after implementing recommendations, the cause is often poor event tracking. Many developers incorrectly define product views: they use viewDidAppear — and the model gets noisy data. We build infrastructure that actually boosts conversion. Our experience: 10+ years in mobile development, 40+ projects with recommendation modules. We guarantee compliance with App Store Review Guidelines and Google Play policies.
Personalization in mobile e-commerce is not just a trend but a necessity: without quality recommendations, up to 70% of users leave with an empty feed. A proper recommendation system increases average order value by 15–30% and retention by 20%. The cold start problem is particularly challenging — when the app has little behavioral data. Heuristics help: popular items, editorial picks, geo-recommendations.
Architecture: what the system consists of
A recommendation system has three layers, and the mobile app participates in each.
Event collection. The app generates behavioral signals: product view, add to cart, purchase, time on screen, scroll through feed. These events are sent to an analytics system (Amplitude, Mixpanel, Segment, custom Kafka topic). Data quality is critical: if view_product fires on every scroll past a card, the model gets noisy signals. For correct impression tracking, use a visibility timer (see code below).
Model and offline training. Personalization is built on collaborative filtering (per Wikipedia), content-based filtering by product attributes, or hybrid approaches. For e-commerce with cold start (new users, new items), pure CF doesn't work — fallback strategies based on attributes are needed. A hybrid approach provides up to 20% more accuracy compared to pure CF.
Delivery of recommendations. The mobile app requests recommendations via API and receives an ordered list of items. Key factors: response time (< 200ms for inline blocks), cache TTL, graceful degradation when the service is unavailable. 95% uptime is maintained via CDN and Redis.
Why event tracking is the biggest bottleneck?
The most common oversight is incorrectly defining a product "view". viewDidAppear on the product screen fires before the user actually sees the content. For impression tracking in lists, use UICollectionView.indexPathsForVisibleItems with a timer:
// iOS: count impression only if item is visible > 1 second
private var impressionTimers: [IndexPath: Timer] = [:]
func collectionView(_ collectionView: UICollectionView,
willDisplay cell: UICollectionViewCell,
forItemAt indexPath: IndexPath) {
let timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: false) { [weak self] _ in
guard let product = self?.products[indexPath.item] else { return }
Analytics.track(.productImpression(productId: product.id, source: .recommendations))
}
impressionTimers[indexPath] = timer
}
func collectionView(_ collectionView: UICollectionView,
didEndDisplaying cell: UICollectionViewCell,
forItemAt indexPath: IndexPath) {
impressionTimers[indexPath]?.invalidate()
impressionTimers.removeValue(forKey: indexPath)
}
Implementation details for Android
On Android, the equivalent is RecyclerView + custom OnScrollListener or ViewTreeObserver.OnGlobalLayoutListener with Intersection Observer logic. Use the `Transitions Everywhere` library for smooth appearance.Integration of the recommendation API
Recommendations come in several types with different integration points:
| Type | UI Location | Request Context |
|---|---|---|
| Homepage feed | Main screen | user_id |
| Similar items | Product screen | product_id, user_id |
| Cross-sell | Cart | cart_items[], user_id |
| Post-purchase | Thank you screen | order_id, user_id |
For each type, there is a separate endpoint or a placement parameter. No universal "give me recommendations" request. Caching: homepage recommendations are cached for 30–60 minutes (NSCache on iOS, Room + WorkManager on Android for background refresh). Product screen recommendations — no cache or TTL of 5 minutes; they must reflect the current session.
How to ensure fast recommendation response times?
API response time must be < 200ms for inline blocks. Use CDN for static fallback lists, Redis for computed recommendation cache. On the client, preload the next block on scroll. If the service is unavailable, show an editorial pick from a local config.
Cold start and fallback
New user — no history, no vector. Options:
- Onboarding with category interest selection → send as initial signals
- Popular items in category (editorial picks, not just top sellers)
- Geo-based recommendations (what is bought in this region)
Fallback when recommendation service is unavailable: a ready static "editorial pick" list in config or CDN.
A/B testing
A recommendation system without an A/B test is faith in the model. Each new algorithm is tested via feature flags (Firebase Remote Config, Unleash): 10% traffic on the new model, metric — CTR of the recommendation block and conversion to purchase with a 7-day attribution window. For in-app purchases, use StoreKit 2 on iOS and Google Play Billing 6 on Android. Comparison of approaches:
| Algorithm | CTR | Conversion | Cold start |
|---|---|---|---|
| Collaborative Filtering | 5% | 3% | No |
| Content-based | 4% | 2.5% | Yes |
| Hybrid | 7% | 4.2% | Yes |
What we deliver
- Audit of current event tracking and data schema
- Design of event schema: names, parameters, context
- Integration of recommendation API or custom model development
- Implementation of UI components: horizontal scroll, carousel, inline block with impression tracking
- Caching, fallback, and offline mode setup
- A/B testing and definition of success metrics
- Documentation and team training
Work process
- Audit of current event tracking: what is already collected, what needs to be added.
- Design event schema: event names, mandatory parameters, context.
- Integrate recommendation API or develop a custom model (if no ready service).
- Implement UI components: horizontal scroll, carousel, inline block with correct impression tracking.
- Caching, fallback on errors, offline mode.
- Set up A/B testing, define success metrics.
- Deliver documentation and conduct code review.
Timeline estimates
Integration of a ready recommendation API into an existing app: from 1 to 2 weeks. Building a system from scratch, including data collection, model, API, and mobile part: from 2 to 3 months. Cost is determined after analysis of your current stack and catalog size. Contact us for an audit — we will evaluate your system and propose a solution. Get a consultation on implementation.